Ki jan yo konekte yon aplikasyon Express nan Postgres lè l sèvi avèk Sequelize

Introduction nan

PostgreSQL (koroze kòm Postgres) se youn nan baz done ki pi itilize nan konstriksyon aplikasyon lojisyèl. Postgres se yon jeneral-purpose, sous louvri, sistèm jesyon baz done objè-relasyonèl (RDBMS). Youn nan avantaj yo nan lè l sèvi avèk Postgres se sipò pou tou de relasyonèl (SQL) ak non-relasyonèl (NoSQL) kesyon.

Youn nan fason yo konekte yon baz done nan yon aplikasyon entènèt se lè l sèvi avèk yon ORM (Object Relational Mapper). Yon ORM ap travay kòm yon kouch nan kominikasyon ant aplikasyon ou ak databas la. Objektif la nan tutorial sa a se yo eksplike ki jan ou ka sèvi ak Postgres nan aplikasyon Express ou nan Sequelize ORM.

Sequelize ORM se dekri kòm:

Yon modèn TypeScript ak Node.js ORM pou Oracle, Postgres, MySQL, MariaDB, SQLite, ak SQL sèvè, ak plis ankò.

Yon modèn TypeScript ak Node.js ORM pou Oracle, Postgres, MySQL, MariaDB, SQLite, ak SQL sèvè, ak plis ankò.Sequelize dokiman

Ou pral bati yon API jesyon travay senp. API a pral kapab kreye, lis, mete ajou estati konplèks, ak retire travay.

Tutorial sa a se premye nan yon seri ap vini an de tutorials konsantre sou lè l sèvi avèk baz done relasyonèl nan Express lè l sèvi avèk Sequelize. Nan tutorials ap vini an, ou pral eksplore sèk baz done, migrasyon, ak asosyasyon nan Sequelize.

Kondisyon

Pou kontinye ak tutorial sa a, ou pral bezwen sa a:

• Yon editè tèks (pou egzanp, VS Kòd)
• Yon kliyan API pou tès endpoints (pou egzanp, Postman)
• Node.js se enstale sou òdinatè ou
• Konesans prensipal nan Express
• Yon instans nan Postgres ki kouri lokalman oswa distansman

Pwojè Setup

Nou pral kòmanse pa mete dosye apwopriye ak katwòch pou kreye yon aplikasyon Express ak enstale pakè yo nesesè. Komand yo itilize yo sèlman aplike nan yon terminal Linux.

1. Create the project directory:

       mkdir tasks-manager-api
   

2. Navigate to the project directory:

       cd tasks-manager-api
   

3. Initialize the NPM package by running the following command to create a package.json file with default settings:

       npm init -y
   

4. Install Express and other core dependencies:

      npm install express express-async-errors dotenv && npm install nodemon --save-dev
   

5. Install Postgres driver for Node.js:

      npm install pg
   

6. Install Sequelize:

      npm install sequelize
   

7. In the root directory, create the models and utils folders:

   mkdir models utils
   

8. In the root directory, create a .env file, which will contain the server’s port number and the database URL of any Postgres instance:

   PORT=5000
   DATABASE_URL=postgres://<user>:<password>@<host>:<port>/<database>
   

9. In the root directory, create the index.js file, which is the application entry point:

      touch index.js
   

10. Set up the command to run the local development server by editing the scripts object in package.json:

    {
        //…
        "scripts": {
            "test": "echo \"Error: no test specified\" && exit 1",
            "dev": "nodemon index.js",
            "start": "node index.js"
        },
        //…
    }
    

Struktura nan dosye pwojè ta dwe tankou sa a:

Konfigirasyon nan sequelize

Kreye de dosye nanutilsDirecteur nan:config.jsakdb.js.

Chanjman anviwònman chanjman

nanconfig.jsdosye, chaje varyab anviwònman soti nan.envDosye ki itilize nandotenvpakè. Lè sa a, ekspòtePORTakDATABASE_URLvaryab pou yo ka aksè nan lòt pati nan aplikasyon an.

nanconfig.jsDosye a ta dwe gen kontni sa yo:

require('dotenv').config()

const PORT = process.env.PORT || 3000
const DATABASE_URL = process.env.DATABASE_URL

module.exports = {
    PORT,
    DATABASE_URL
}

Kreye yon sequelize instance

nandb.jsdosye, kreye yon enstans Sequelize. Ou ka kreye yon enstans Sequelize pa pase URI koneksyon baz done a (ki estoke nanDATABASE_URL) nan sequelize constructor. Lè sa a, ou kreye yon fonksyonconnectToDB,ki pral tès koneksyon la nan baz baz la pa releauthenticatefonksyon. Finalman, ou ekspòteconnectToDBfonksyon ak sequelize enstans la.

nanutils/db.jsDosye a ta dwe gen kontni sa yo:

const Sequelize = require("sequelize");
const { DATABASE_URL } = require("./config");

const sequelize = new Sequelize(DATABASE_URL)

const connectToDB = async () => {
    try {
        await sequelize.authenticate()
        console.log("Database connection established successfully.")
    } catch (error) {
        console.log("Unable to connect to the database:", error)
        return process.exit(1)
    }
    return null
}

module.exports = {
    connectToDB,
    sequelize
}

Definisyon nan modèl la Task

Yon modèl sequelize se yon reprezantan nan yon tab nan baz done a. Ou ka definiTaskmodèl pa extending sequelizeModelklas ak releModel.init(attributes, options)Fòmasyon

nanmodelsDirectory, kreye nantask.jsDosye ak kontni sa yo:

const {Model, DataTypes} = require("sequelize")
const {sequelize} = require("../utils/db")

class Task extends Model {}

Task.init({
    id: {
        type: DataTypes.INTEGER,
        autoIncrement: true,
        primaryKey: true
    },
    title: {
        type: DataTypes.STRING,
        allowNull: false
    },
    completed: {
        type: DataTypes.BOOLEAN,
        defaultValue: false
    }
}, {
    sequelize,
    modelName: "Task",
    timestamps: true,
    underscored: true,
    defaultScope: {
        attributes: {
            exclude: ["createdAt", "updatedAt"]
        }
    }
})

Task.sync()

module.exports = Task

nanattributesparamèt definye estrikti a nanTasktab nan baz done a.Taskmodèl la gen twa atribit:

• id: Yon jaden nimewo enteryè ki se yon kle prensipal otomatikman ogmante ki itilize pou inikman identifye chak enskripsyon.
• Tit: Yon jaden string ki reprezante non an nan travay la.
• konplete: Yon jaden konplete gen yon valè Boolean ki endike si aktivite a te konplete.

nanoptionsparamèt konfigire ki jan Sequelize trete modèl la.TaskModèl la gen opsyon yo sa yo:

• sequelize: Enstans la Sequelize ki te kreye pi bonè nan utils/db.js.
• modelName: Non nan tab la ki te kreye nan baz done a.
• Timestamps: Lè mete nan True, ajoute la kreyeAt ak ajouAt jaden otomatikman nan modèl la.
• souligned: Lè mete nan True, konvèti jaden Camel Case nan ka Snake nan baz done a.
• defaultScope: Eksepsyon kèk atribit pa default lè fè kesyon.

nanTask.sync()fonksyon sinkronize modèl la ak baz done a pa kreye tab la si tab la pa egziste. Sepandan, ou ta dwe note ke sinkronizasyon ta dwe fè lè l sèvi avèk migrasyon.

Kreye sèvè Express

Finalman, ou mete li tout ansanm pa kreye Express sèvè a. Nanindex.jsdosye, ou konfigirasyon middleware a nesesè, definye API endpoint wout yo, ak kouri sèvè a ekspres.

nanstartfonksyon se responsab pou inisyalize sèvè a Express.startfonksyon an premye teste koneksyon la nan baz done a pa releconnectToDB()fonksyon. Si koneksyon an se siksè, li kòmanse Express sèvè a, ki koute sou pò a espesifye.

nanindex.jsDosye a gen kontni sa yo:

require("express-async-errors");
const express = require("express");
const app = express();
const { PORT } = require("./utils/config");
const { connectToDB } = require("./utils/db");
const Task = require("./models/task");

// middlewares
app.use(express.json());

// routes
app.get("/api/tasks", async (req, res) => {
  const tasks = await Task.findAll();
  res.json({
    message: "List of tasks",
    tasks: tasks,
  });
});

app.post("/api/tasks", async (req, res) => {
  const { title } = req.body;
  const task = await Task.create({ title });
  res.status(201).json({
    message: "Task created successfully",
    task,
  });
});

app.patch("/api/tasks/:id/toggle-completed", async (req, res) => {
  const { id } = req.params;
  const task = await Task.findByPk(id);
  if (!task) {
    return res.status(404).json({ message: "Task not found" });
  }
  task.completed = !task.completed;
  await task.save();
  res.json({
    message: task.completed
      ? "Task marked as completed"
      : "Task marked as not completed",
    task,
  });
});

app.delete("/api/tasks/:id", async (req, res) => {
  const { id } = req.params;
  const task = await Task.findByPk(id);
  if (!task) {
    return res.status(404).json({ message: "Task not found" });
  }
  await task.destroy();
  res.json({
    message: "Task deleted successfully",
  });
});

const start = async () => {
  try {
    await connectToDB();
    app.listen(PORT, console.log(`Server is running on port ${PORT}`));
  } catch (error) {
    console.error(error);
    process.exit(1);
  }
};

start();

Tès nan API Endpoint

Koulye a, ou ka kontinye tès API Endpoints:

1. Kreye yon nouvo travay—POST /api/tasks:

2. List tout travay—GET /api/tasks:

3. Toggle konplètman estasyon—PATCH /api/tasks/:id/toggle-konplete:

4. Retounen yon Task—DELETE /api/task:

Konklisyon

Ou kounye a konnen ki jan yo konekte yon aplikasyon Express nan yon baz done Postgres lè l sèvi avèk Sequelize. Ou te bati yon API manadjè travay senp, ak nan pwosesis la, ou konfigirasyon Sequelize, konekte Sequelize nan yon instans Postgres, definyeTaskmodèl, epi li te kreye API Endpoints.

Koulye a, logik kontwòl la se ekri nanindex.jsnan tutorials ki ap vini an, nou pral refactor sa a baz kòd nan yon estrikti plis scalable lè l sèvi avèk kontwoleurs, routeur, ak migrasyon Sequelize.

Pou yon lis plis, ou ta dwe pase nanSequelize dokimanyo aprann plis sou modil kesyon, validasyon, asosyasyon, ak plis ankò.

Ou ka jwenn kod la sous konplè pou tutorial sa a souGitHub nan.

Resous

• Sequelize Dokimantasyon (v6)
• Ki sa ki nan PostgreSQL? - AWS
• Sèvi ak baz done relasyonèl ak Sequelize – FullStackOpen
• Dokiman nan Express.js