Sequelize භාවිතා කිරීමෙන් Postgres වෙත Express යෙදුම සම්බන්ධ කරන්නේ කෙසේද

ඇතුළත් කිරීම

PostgreSQL (Postgres ලෙස කෙටි කිරීම) යනු මෘදුකාංග යෙදුම් ගොඩනැගීමේදී වඩාත් භාවිතා වන දත්ත පදනමකි. Postgres යනු පොදු අරමුණක් සහිත, විවෘත මූලාශ්රය සහිත, ඔන්ලයින්-විශේෂ දත්ත පදනම කළමනාකරණ පද්ධතියකි (RDBMS). Postgres භාවිතා කිරීමෙන් ලැබෙන වාසි වලින් එකක් වන්නේ සබඳතා (SQL) සහ Non-relational (NoSQL) ප්රශ්න දෙකම සඳහා සහාය වීමයි.

වෙබ් යෙදුම සමඟ දත්ත සබැඳීමේ ක්රමයක් වන්නේ ORM (Object Relational Mapper) භාවිතා කිරීමයි. ORM ඔබගේ යෙදුම සහ දත්ත සන්නිවේදන මට්ටම ලෙස ක්රියා කරයි. මෙම උපාය මාර්ගයේ අරමුණ වන්නේ ඔබ Sequelize ORM හරහා ඔබේ Express යෙදුම තුළ Postgres භාවිතා කළ හැකි ආකාරය පැහැදිලි කිරීමයි.

Sequelize ORM ලෙස හැඳින්වේ:

Oracle, Postgres, MySQL, MariaDB, SQLite, සහ SQL Server සඳහා නවීන TypeScript සහ Node.js ORM සහ තවත් බොහෝ දේ සඳහා. — Sequelize Documentation

Oracle, Postgres, MySQL, MariaDB, SQLite, සහ SQL Server සඳහා නවීන TypeScript සහ Node.js ORM සහ තවත් බොහෝ දේ සඳහා. — Sequelize Documentation

ඔබ සරල කාර්ය කළමනාකරණ API නිර්මාණය කරනු ඇත. API නිර්මාණය, ලැයිස්තුව, සම්පූර්ණ කිරීමේ තත්වය යාවත්කාලීන කිරීම සහ කාර්යයන් ඉවත් කිරීමට හැකි වනු ඇත.

මෙම උපාධිය Sequelize භාවිතා කිරීමෙන් Express හි සබඳතා දත්ත පදනම භාවිතා කිරීම පිළිබඳ උපාධි කිහිපයක පළමු වන අතර, ඉදිරි උපාධි වලදී, ඔබ Sequelize හි දත්ත සබඳතා, ප්රවාහනය සහ සබඳතා පරීක්ෂා කරනු ඇත.

කොන්දේසි

මෙම උපාංගය සමඟ ඉදිරියට යාම සඳහා, ඔබට අවශ්ය වේ:

• Text Editor (උදාහරණයක් ලෙස VS Code)
• Endpoints පරීක්ෂා කිරීම සඳහා API සේවාදායකය (උදා: Postman)
• Node.js ඔබගේ පරිගණකයට ස්ථාපිත කර ඇත
• Express පිළිබඳ මූලික දැනුම
• ස්ථාපිතව හෝ දුරස්ථව ක්රියාත්මක කරන Postgres උදාහරණයක්

ව් යාපෘතිය Setup

අපි Express යෙදුම නිර්මාණය කිරීම සඳහා සුදුසු ගොනු සහ ලිපිගොනු ස්ථාපනය කිරීම සහ අවශ්ය පැකේජ ස්ථාපනය කිරීම ආරම්භ කරමු.

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"
        },
        //…
    }
    

ව්යාපෘති ගොනුව ව්යාපෘති ගොනුව මෙහෙමයි:

Sequelize සකස් කිරීම

ෆයිල් දෙකක් හදන්නutilsඅධ් යක්ෂණය :config.jsසහdb.js.

වායුගෝලීය වෙනස්කම්

ඒ අතරේconfig.jsගොනුව, පරිසර වෙනස්කම් බාගත කිරීම.envභාවිතා කරන ෆයිල්dotenvඉන්පසු ExportPORTසහDATABASE_URLවෙනස්කම්, එබැවින් එය අයදුම් කිරීමේ වෙනත් කොටස්වල ප්රවේශ විය හැක.

ඒconfig.jsගොනුව පහත සඳහන් අන්තර්ගතයක් විය යුතුය:

require('dotenv').config()

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

module.exports = {
    PORT,
    DATABASE_URL
}

Sequelize Instance නිර්මාණය කිරීම

ඒ අතරේdb.jsඔබගේ database connection URI (අදාල database connection URI) හරහා Sequelize instance එකක් නිර්මාණය කළ හැකිය.DATABASE_URL(Sequelize constructor) යන්න, එවිට ඔබ Function එකක් නිර්මාණය කරයි.connectToDB,Database එකට සම්බන්ධතාවය පරීක්ෂා කරන්න.authenticateඅවසාන වශයෙන්, ඔබ ExportconnectToDBFunction සහ Sequelize

ඒutils/db.jsගොනුව පහත සඳහන් අන්තර්ගතයක් විය යුතුය:

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
}

Task Model හඳුනා ගැනීම

A Sequelize model is a representation of a table in the database. ඔබ දත්ත සකස් කළ හැක.Taskදිගුකාලීන කිරීමෙන් SequelizeModelඋපාධි සහ ඇමතුම්Model.init(attributes, options)ක් රියාකාරිත්වය

ඒ අතරේmodelsඅධ් යක්ෂණය, Create thetask.jsපහත සඳහන් අන්තර්ගතයන් සහිත ගොනුවක්:

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

ඒattributesParameter defines the structure of theTaskදත්ත දත්ත දත්ත දත්ත දත්ත දත්ත.TheTaskආකෘතියට ප් රභේද තුනක් ඇත:

• id: සෑම ලියාපදිංචියකටම නිශ්චිතව හඳුනා ගැනීම සඳහා භාවිතා කරන ස්වයංක්රීයව වැඩිවන ප්රධාන ක්ෂේත් රයකි.id: An integer field which is an automatically increasing primary key used to uniquely identify each record.
• Title: කාර්යය නාමය ප්රදර්ශනය කරන string field එකක්.
• සම්පූර්ණ කිරීම: සම්පූර්ණ කළ ක්ෂේත් රයේ Boolean අගය ඇති අතර එය කාර්යය සම්පූර්ණ කර ඇති බව පෙන්වයි.

ඒoptionsParameter Configures how Sequelize handles the model.කෙළියක හැසිරෙන ආකාරයTaskමෙම ආකෘතියට පහත සඳහන් විකල්ප ඇත:

• sequelize: Utils/db.js හි කලින් නිර්මාණය කරන Sequelize උදාහරණය.
• modelName: Database හි නිර්මාණය කරන ලද පරිගණකයේ නම.
• timestamps: true ලෙස සකස් කරන විට, createdAt සහ updatedAt ක්ෂේත් ර ස්වයංක්රීයව ආකෘතියට එකතු කරයි.
• සලකා බලන විට True, Database වල Snake Case වලට camel Case ක්ෂේත්ර පරිවර්තනය කරයි.
• defaultScope: ප්රශ්නය කරන විට නිශ්චිත ලක්ෂණ සීමා කරයි.

ඒTask.sync()Function සංකේතය පුවරුවක් නොමැති නම් පුවරුවක් නිර්මාණය කිරීමෙන් ආකෘතිය සහ දත්ත සංකේතය සමඟ සංකේත කරයි.H, you should note that synchronization should be done using migrations.

Express Server නිර්මාණය කිරීම

අවසාන වශයෙන්, ඔබ එය සියලු එකතු කිරීම මගින් Express සේවාදායක නිර්මාණය.index.jsfile, ඔබ අවශ්ය middleware ස්ථාපනය, API endpoint මාර්ගය සකස්, සහ Express සේවාදායකය ක්රියාත්මක.

ඒstartExpress Server එක මුලින්ම හදන එක තමයි ප් රශ්නය.startදත්ත සබැඳියකට මුලින්ම සන්නිවේදන පරීක්ෂා කිරීමconnectToDB()සන්නිවේදනය සාර්ථක නම්, එය Express සේවාදායක ආරම්භ කරයි, සවන් සපයනු ලැබේ.

ඒindex.jsෆයිල් එක ඇතුළත් වන්නේ පහත පරිදි:

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();

API Endpoint භාවිතය

දැන් ඔබට API Endpoints පරීක්ෂා කර ගත හැකිය:

1. නව කාර්යයක් නිර්මාණය කිරීම — POST /api/tasks:

2. සියලු කටයුතු ලැයිස්තුව—GET /api/tasks:

3. Toggle සම්පූර්ණ තත්ත්වය—PATCH /api/tasks/:id/toggle-completed:

4. අයින් කරන්න Task—DELETE /api/task:

ප් රතිඵල

දැන් ඔබට Sequelize භාවිතා කිරීමෙන් Express යෙදුම Postgres දත්ත සබැඳි කරන්නේ කෙසේද යන්න දන්නවා.ඔබ සරල කාර්ය කළමනාකරණ API නිර්මාණය කර ඇති අතර, මෙම ක්රියාවලිය තුළදී, ඔබ Sequelize සකස් කර, Sequelize Postgres උදාහරණයට සම්බන්ධ කර,Taskඒ නිසා තමයි API Endpoints හදලා තියෙන්නේ.

අද වන විට, controller logic ලිඛිතව ලිඛිතවindex.jsපහසුකම් සඳහා ගොනුව.අපේ ඉදිරි ඉගැන්වීම් වලදී, අපි මෙම කේත පදනම පුළුල් කළමනාකරණ, රොයිටර් සහ Sequelize ප්රවාහන භාවිතා කිරීමෙන් වඩාත් පුළුල් කළ හැකි ව්යුහයක් බවට පත් කරනු ඇත.

වැඩිදුර කියවීම සඳහා, ඔබ හරහා යන්නඋපුටා ගැනීමේ ලේඛනආකෘති ප්රශ්න, සම්මත කිරීම්, සබඳතා සහ තවත් දේවල් ගැන වැඩි විස්තර දැනගන්න.

ඔබට මෙම ඉඟි සඳහා සම්පූර්ණ මූලාශ්ර කේතය සොයා ගත හැකියGithub.

සම්පත්

• පරිගණක සකස් කිරීම (v6)
• PostgreSQL යනු කුමක්ද?
• Relational Databases with Sequelize – FullStackOpen භාවිතා කිරීම
• Express.js ලිපිනය