12/8 部課

Review: Workflow

Ref: https://www.youtube.com/watch?app=desktop&v=YGxrvHGCJ2Y

Frontend to Backend: Application layer(應用層) under TCP/IP model
List of Protocols in Application layer: https://www.geeksforgeeks.org/application-layer-protocols-in-tcp-ip/

HTTP requests

1. Request Line
   
2. HTTP headers
   
3. Message body

GET Method usually does not include message body.

Message bodies are appropriate for some request methods and inappropriate for others. For example, a request with the POST method, which sends input data to the server, has a message body containing the data. A request with the GET method, which asks the server to send a resource, does not have a message body.

HTTP response

1. Status line
2. HTTP headers

3. Message body
   For the example above, it will return corresponding html script.

Database

What is a database?

A database, in the most general sense, is an organized collection of data. More specifically, a database is an electronic system that allows data to be easily accessed, manipulated and updated.

When people refer to a “database” they’re often talking about a computer program that allows them to interact with their database. These programs, known more formally as a database management system (DBMS), are often installed on a virtual private server and accessed remotely.

Relational Databases(RDBMSs)

• Data are stored by multiple tables
• A table is constructed with a set of tuples, or rows in a table, with each tuple sharing a set of attributes, or columns
• There exists some explicit relations between data, but only useful if you can retrieve it.

(ref: https://www.digitalocean.com/community/conceptual-articles/an-introduction-to-databases)

• Uses Structured Query Language(SQL) to manage and query data
• Examples: MySQL, PostgreSQL, SQLite, …

Problems with RDBMS:

• Not always every set of data exist explicit relations with each other
• Must specify unique attribute

Non-relational Databases(NoSQL databases)

• Does not implement SQL
• Not need relations, being more flexible with data storing
• Difficulty of choosing NoSQL

• Redis: Key-Value Databases
• MongoDB: Document-Oriented Databases

Object Relational Mapping (ORM)

When interacting with a database using OOP languages, you'll have to perform different operations like creating, reading, updating, and deleting (CRUD) data from a database. By design, you use SQL for performing these operations in relational databases.

While using SQL for this purpose isn't necessarily a bad idea, the ORM and ORM tools help simplify the interaction between relational databases and different OOP languages.

For example, if we want to find a todo item named "buying an apple" and haven't done(done = False) in Todo database, we can access it by using ORM syntax:

Todo.find ({ name: 'buying an apple', done: { false }})

Using SQL syntax:

SELECT * FROM Todos WHERE name='buying an apple' AND done=FALSE;

MongoDB

• NoSQL, Document-Oriented

Document-Oriented: Mixture of Relational & Key-Value Databases

• Format

Todo.find()[0].username

{
    "_id": { "$oid": "6572e1cef219bca05511d230" },
    "id": { "$numberInt": "1" },
    "username": "admin",
    "passwd": "$2a$10$/sbmKQjOpqfeeZ1gFEyaauNC5GxNL6yTgJP/AIbGCN9DpyxOMv9Ou",
    "identity": "Admin",
    "events": [],
    "isLoggedIn": false,
    "loggedInAt": { "$date": { "$numberLong": "1672993352831" } },
    "__v": { "$numberInt": "0" }
}

MongoDB Atlas

• Free service from MongoDB official

https://lyunotes.blogspot.com/2020/11/day12-mongodb-atlas.html
https://www.mongodb.com/
https://www.mongodb.com/atlas/database

Start !!!

Step 1: Connection

In server.js:

const mongoose = require("mongoose");
require("dotenv").config();

const { MONGO_USERNAME, MONGO_PASSWORD } = process.env;
const uri = `mongodb+srv://${MONGO_USERNAME}:${MONGO_PASSWORD}@cluster0.ogm4i.mongodb.net/myFirstDatabase?retryWrites=true&w=majority`;
// this can be copied in MongoDB Atlas

mongoose
  .connect(uri, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  });

const db = mongoose.connection;
db.on("err", (err) => {
  console.error(err);
});
db.on("open", () => {
  console.log("Successfully connect to mongoDB");
});

in .env:

MONGO_USERNAME=
MONGO_PASSWORD=

Install dotenv-defaults if Error

npm install dotenv

Step 2: Define Schema

Create a model directory
In user.js:

const mongoose = require("mongoose");
const Schema = mongoose.Schema;

const UserSchema = new Schema({
  id: {
    type: Number,
    required: [true, "Id field is required."],
  },
  name: {
    type: String,
    required: [true, "Name field is required."],
  },
});
// Creating a table within database with the defined schema
const User = mongoose.model("User", UserSchema);
// Exporting table for querying and mutating
module.exports = User;

In server.js: Import User Schema

const User = require("./model/user");

Step 3: Define Mutation Function

In server.js:

const saveUser = async (id, name) => {
  const existing = await User.findOne({ name: name });
  if (existing) {
    console.log(`Username ${name} already exists!!`);
    return;
  }
  try {
    const newUser = new User({ id, name });
    console.log("Created user", newUser);
    await newUser.save();
    console.log("Successfully saved");
    return;
  } catch (e) {
    throw new Error("User creation error: " + e);
  }
};

const DeleteDB = async () => {
  try {
    await User.deleteMany({});
    console.log("Database deleted");
  } catch (e) {
    throw new Error("Database deletion failed");
  }
};

Mutation: to mutate -> to modify data (CRUD operations)

Step 4: Define Route to call Mutation Functions

In server.js

const router = require("router");
router.post("/saveuser", saveUser)

// More Routers

app.use("/", router)

Or just

app.route("/saveuser")
  .get((req, res) => {
  // do something
})