Configuración de una API de nodo con Postgres y Knex

En este artículo, configuraría un proyecto Node con la base de datos Postgres y el generador de consultas Knex.

¿Qué es Knex?

Knex.js es un generador de consultas SQL con “baterías incluidas” para Postgres, MSSQL, MySQL, MariaDB, SQLite3, Oracle y Amazon Redshift diseñado para ser flexible, portátil y divertido de usar.

Para empezar, tenemos que inicializar nuestro proyecto para crear nuestro package.json expediente.

npm init -y

Configuración de la base de datos

Estaría usando una base de datos en línea llamada Elephantsql para configurar mi base de datos. Te puedes registrar aquí.

Después de registrarse, cree una base de datos. A continuación se muestra un ejemplo.

Configurar Knex

Instalar las dependencias necesarias para el proyecto.

npm i knex -g
npm i pg express dotenv --save

Crear un .env archivo en la raíz de su proyecto y agregue la URL de la base de datos. Ejemplo a continuación.

DB_URL=URL (where URL is the database connection string)

En su terminal, ejecute el siguiente comando para inicializar knex

knex init

El comando anterior generaría un knexfile.js en la raíz de su proyecto y se vería a continuación.

// Update with your config settings.

module.exports = {

  development: {
    client: 'sqlite3',
    connection: {
      filename: './dev.sqlite3'
    }
  },

  staging: {
    client: 'postgresql',
    connection: {
      database: 'my_db',
      user:     'username',
      password: 'password'
    },
    pool: {
      min: 2,
      max: 10
    },
    migrations: {
      tableName: 'knex_migrations'
    }
  },

  production: {
    client: 'postgresql',
    connection: {
      database: 'my_db',
      user:     'username',
      password: 'password'
    },
    pool: {
      min: 2,
      max: 10
    },
    migrations: {
      tableName: 'knex_migrations'
    }
  }

};

voy a cambiar el knexfile.js archivo de configuración a utilizar Postgres y también especificar el directorio donde se deben guardar mis migraciones y semillas. Editar el knexfile.js archivo al código de abajo.

require('dotenv').config();

module.exports = {
  development: {
    client: 'pg',
    connection: process.env.DB_URL,
    migrations: {
      directory: './data/migrations',
    },
    seeds: { directory: './data/seeds' },
  },

  testing: {
    client: 'pg',
    connection: process.env.DB_URL,
    migrations: {
      directory: './data/migrations',
    },
    seeds: { directory: './data/seeds' },
  },

  production: {
    client: 'pg',
    connection: process.env.DB_URL,
    migrations: {
      directory: './data/migrations',
    },
    seeds: { directory: './data/seeds' },
  },
};


Configuración de base de datos

Crear un db.js archivo en el data directorio que contendría nuestra configuración knex en el directorio de datos. Esto mantendría la configuración para nuestros entornos.

Agregue el siguiente código a la db.js expediente.

const knex = require('knex');

const knexfile = require('../knexfile');


const env = process.env.NODE_ENV || 'development';
const configOptions = knexfile[env];

module.exports = knex(configOptions);

Migraciones

Las migraciones le permiten definir conjuntos de cambios de esquema, por lo que actualizar una base de datos es muy sencillo.

Para crear/generar un archivo de migración, ejecute el siguiente comando.

knex migrate:make todo 

Nota: todo en el comando anterior es el nombre de la migración.

El comando anterior crearía un archivo de migración en la ruta especificada para las migraciones. En nuestro caso /data/migrations

Luego podemos editar el archivo de migración para incluir las columnas que necesitaríamos en nuestra tabla de tareas pendientes.

exports.up = knex =>
  knex.schema.createTable("todo", tbl => {
    tbl.increments();
    tbl.text("task", 128).notNullable();
  });

exports.down = knex => knex.schema.dropTableIfExists("todo");

Para ejecutar las migraciones, puede ejecutar el siguiente comando

knex migrate:latest

knex migrate:latest ejecutaría todos nuestros archivos de migración y ejecutaría el up funciones que luego crearían las tablas en nuestra base de datos.

Para revertir las migraciones, puede ejecutar el siguiente comando

knex migrate:rollback

knex migrate:rollback ejecutaría todos nuestros archivos de migración y ejecutaría el down funciones que luego colocarían las tablas en nuestra base de datos.

Semillas

Los archivos semilla le permiten llenar su base de datos con datos de prueba o semilla independientemente de sus archivos de migración.

Para generar semillas, ejecute el siguiente comando en su terminal

knex seed:make todo

Esto crearía un todo.js archivo en su directorio de semillas. especificado para semillas en nuestro knexfile.jsque luego se puede editar para incluir nuestros datos de prueba.
Ejemplo de un archivo semilla a continuación.


exports.seed = function(knex) {
  // Deletes ALL existing entries
  return knex('todo').del()
    .then(function () {
      // Inserts seed entries
      return knex('todo').insert([
        {id: 1, task: 'Create API'},
        {id: 2, task: 'Watch Money Heist'},
        {id: 3, task: 'Do Dishex'}
      ]);
    });
};

Para ejecutar los archivos de semillas, podemos ejecutar el siguiente comando en su terminal

knex seed:run 

El comando de ejecución luego obtiene todos los archivos de semillas y luego los envía a nuestra base de datos.

Guiones

Puede agregar secuencias de comandos a package.json expediente.

 "scripts": {
    "start": "node index",
    "migrate": "knex migrate:latest",
    "unmigrate": "knex migrate:rollback",
    "seed": "knex seed:run "
  }

start: Este comando es para iniciar nuestra aplicación.
migrate: Este comando es para agregar nuestras migraciones a nuestra base de datos.
unmigrate: Este comando es para revertir/eliminar todas las migraciones existentes de la base de datos.

Para consultar la base de datos, todo lo que necesita hacer es importar en el db.js archivo que creamos y hacemos la consulta. A continuación se muestra un ejemplo.

const db = require("./data/db.js"); // importing the db config

app.get("/todo", async (req, res) => {
  const todos = await db("todo"); // making a query to get all todos
  res.json({ todos });
});

Conclusión

En este artículo, hemos podido ver cómo configurar una API de nodo con una base de datos de Postgres y un generador de consultas Knex.

El código fuente utilizado en la demostración de este artículo se puede encontrar aquí.

Encuentre más información sobre knex aquí

Si tiene alguna pregunta o comentario, por favor deje un comentario.

Gracias por leer.

Este artículo fue publicado originalmente en mi Blog

Similar Posts

Leave a Reply

Your email address will not be published.