Forem: Carlos Daniel Ortega Hernandez

Eloquent ORM relationship (part 1)

Carlos Daniel Ortega Hernandez — Wed, 28 Dec 2022 06:50:25 +0000

Relational database

A relational database is one that allows us to divide a record into several tables.

One-to-one relationship

A one-to-one relationship in a database is a relationship between two tables where each record in one table is related to exactly one record in the other table.

note: With the command 'php artisan make:model Profile -mf' the model and the factory are created and the migration is created. The first letter must be capitalized and the word singular.

An example of this is relating a user to a profile, a user has a profile and a profile belongs to a user.

For this we use the hasOne method.

public function profile()
{
    return $this->hasOne(Profile::class);
}

One-to-many relationship

A one-to-many relationship in a database refers to a relationship between two entities, in which an instance of one entity is associated with zero, one, or many instances of the other entity

For this we use the hasMany method.

public function users()
{
    return $this->hasMany(User::class);
}

And the method we use at the model level is belongsTo.

public function level()
{
    return $this->belongsTo(Level::class);
}

This way we will be able to see to which level the user belongs.

Many-to-many relationship

A many-to-many relationship in a database refers to a relationship between two entities, in which an instance of one entity can be associated with zero, one, or many instances of the other entity, and vice versa.

To make a many-to-many relationship we need an intermediate table in which we have the foreign keys of each table, as in the following example in a relationship of the tables groups and users.

And the method we use is the belongsToMany

public function groups()
{
    return $this->belongsToMany(Group::class);
}

public function users()
{
    return $this->belongsToMany(Users::class);
}

To configure the date of creation and update, that appear in null, for it the following method is placed. Which what it does is to put the dates automatically, you can also remove the $table->timestamps(); so that it does not have those columns.

public function users()
{
    return $this->belongsToMany(Users::class)->withTimestamps();
}

One-to-one relationship through...

A one-to-one relationship through another table refers to a relationship between two tables in a database in which each row in one table has a relationship with a row in the other table, and this relationship is established through an intermediate table.

To do this we use the hasOneThrough method, that way we can query a field of the table without calling the one in between.

public function location()
{
    return $this->hasOneThrough(Location::class, Profile::class);
}

That would translate as user has location through profile.

The profile model must have the hasOne method, for the method to work.

public function location()
{
    return $this->hasOne(Location::class);
}

Build a Node.js and Express.js API with Typescript.

Carlos Daniel Ortega Hernandez — Wed, 18 May 2022 00:20:05 +0000

Structure of files

├── build
├── node_modules
├── src
│   ├── data
│   │   └── tasks.json
│   ├── routes
│   │   └── task-routes.ts
│   ├── services
│   │   └── task-service.ts
│   ├── index.ts
|   └── types.d.ts
├── .gitignore
├── package-lock.json
├── package.json
└── tsconfig.json

Initialize the project

First, we need to initialize the project.

npm init -y

Install packages

Install dependencies of the project.

npm install --save express

And install dev dependencies of the project.

npm install --save-dev @types/express typescript ts-node-dev

express: is a Node.js web application framework.
@types/express: is a TypeScript definition file for the express module.
typescript: is a TypeScript compiler.
ts-node-dev: is a TypeScript compiler that runs the server with TypeScript.

Add scripts to package.json

Add scripts to package.json.

"scripts": {
    "dev": "ts-node-dev src/index.ts",
    "start": "node build/index.js",
    "tsc": "tsc"
}

dev: is a command to run the server with TypeScript.
start: is a command to run the server.
tsc: is a command to compile the TypeScript code.

Initialize TypeScript

Now initialize TypeScipt:

$ npm run tsc -- --init

This will create a tsconfig.json file, which is a TypeScript configuration file.

Configure TypeScript

For this project, we use the following configuration:

{
    "compilerOptions": {
        "target": "es2016",
        "module": "commonjs",
        "resolveJsonModule": true,
        "outDir": "./build",
        "esModuleInterop": true,
        "forceConsistentCasingInFileNames": true,
        "strict": true,
        "noUnusedLocals": true,
        "noUnusedParameters": true,
        "noImplicitReturns": true,
        "noFallthroughCasesInSwitch": true,
        "skipLibCheck": true
    }
}

For to know more about the configuration, please visit TypeScript Configuration.

Create a server

In this project, we will create a server with Express.js.

// src/index.ts
import express from 'express';
const app = express();
const PORT = 3000;

app.use(express.json());

app.get('/', (_req, res) => {
    res.send('Hello World!');
});

app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});

And compile the server:

$ npm run dev

Add data to the server

For this project we use the following data:

// src/data/tasks.json
[
    {
        "id": 1,
        "title": "Task 1",
        "description": "Description 1",
        "priority": "High",
        "completed": false,
        "createdAt": "2020-01-01"
    },
    {
        "id": 2,
        "title": "Task 2",
        "description": "Description 2",
        "priority": "Low",
        "completed": false,
        "createdAt": "2020-01-02"
    },
    {
        "id": 3,
        "title": "Task 3",
        "description": "Description 3",
        "priority": "Medium",
        "completed": false,
        "createdAt": "2020-01-03"
    },
    {
        "id": 4,
        "title": "Task 4",
        "description": "Description 4",
        "priority": "High",
        "completed": false,
        "createdAt": "2020-01-04"
    },
    {
        "id": 5,
        "title": "Task 5",
        "description": "Description 5",
        "priority": "Low",
        "completed": false,
        "createdAt": "2020-01-05"
    },
    {
        "id": 6,
        "title": "Task 6",
        "description": "Description 6",
        "priority": "Medium",
        "completed": false,
        "createdAt": "2020-01-06"
    },
    {
        "id": 7,
        "title": "Task 7",
        "description": "Description 7",
        "priority": "High",
        "completed": false,
        "createdAt": "2020-01-07"
    },
    {
        "id": 8,
        "title": "Task 8",
        "description": "Description 8",
        "priority": "Low",
        "completed": false,
        "createdAt": "2020-01-08"
    },
    {
        "id": 9,
        "title": "Task 9",
        "description": "Description 9",
        "priority": "Medium",
        "completed": false,
        "createdAt": "2020-01-09"
    }
]

We need to add types to the tasks.json file.

// src/types.d.ts
export type Priority = 'Low' | 'Medium' | 'High';

export interface BaseTask {
    title: string;
    description: string;
    priority: Priority;
    completed: boolean;
    createdAt: string;
}

export interface Task extends BaseTask {
    id: number;
}

Create the services.

And now we need some services to handle the requests.

// src/services/task-services.ts
import tasksData from '../data/tasks.json';
import { Task, BaseTask } from '../types';

const tasks: Task[] = tasksData as Task[];

export const getAllTasks = ():Task[] => tasks;

export const getTask = (id: number):Task | undefined => tasks.find(task => task.id === id);

export const addTask = (task: BaseTask):void => {
    const newTask = { ...task, id: tasks.length + 1 };
    tasks.push(newTask);
};

export const updateTask = (id: number, task: BaseTask):void => {
    const taskIndex = tasks.findIndex(t => t.id === id);
    if (taskIndex > -1) {
        tasks[taskIndex] = { ...tasks[taskIndex], ...task };
    }
};

export const deleteTask = (id: number):void => {
    const taskIndex = tasks.findIndex(t => t.id === id);
    if (taskIndex > -1) {
        tasks.splice(taskIndex, 1);
    }
};

Add a routes to the server

We will add a route to the server.

// src/routes/task-routes.ts
import express from "express";
const router = express.Router();
import {getAllTasks, getTask, addTask, updateTask, deleteTask} from "../services/task-services";
import {BaseTask} from "../types";

router.get('/', (_req, res) => {
    res.send(getAllTasks());
});

router.get('/:id', (req, res) => {
    const {id} = req.params;
    const task = getTask(Number(id));
    if (task) {
        res.send(task);
    } else {
        res.sendStatus(404);
    }
});

router.post('/', (req, res) => {
    const {title, description, priority, completed, createdAt} = req.body;
    const task: BaseTask = {
        title,
        description,
        priority,
        completed,
        createdAt
    };
    addTask(task);
    res.send({message: 'Task added successfully'});
});

router.put('/:id', (req, res) => {
    const {id} = req.params;
    const {title, description, priority, completed, createdAt} = req.body;
    const task: BaseTask = {
        title,
        description,
        priority,
        completed,
        createdAt
    };
    updateTask(Number(id), task);
    res.send({message: 'Task updated'});
});

router.delete('/:id', (req, res) => {
    const {id} = req.params;
    deleteTask(Number(id));
    res.send({message: 'Task deleted'});
});

module.exports = router;

And now we need to add the routes to the server.

// src/index.ts
app.use("/api/tasks", require("./routes/task-routes"));

We have now created a server api that can be used to get tasks, get task, add, update and delete.

Javascript Loops

Carlos Daniel Ortega Hernandez — Thu, 12 May 2022 23:44:36 +0000

For Loop

For loops are used to iterate over a list.

    for (var i = 0; i < 5; i++) {
        console.log(i);
    }
    // 0
    // 1
    // 2
    // 3
    // 4

While Loop

While loop is used to execute a block of code as long as a condition is true.

    let i = 1;
    while (i < 5) {
        console.log(i);
        i++;
    }
    // 1
    // 2
    // 3
    // 4

Do While Loop

Do While loops are similar to while loops, except that the condition is checked after the code block is run.

    let i = 1;
    do {
        console.log(i);
        i++;
    } while (i < 5);
    // 1
    // 2
    // 3
    // 4

For In Loop

For in loops can be used to loop through the properties of an object.

    const array = [1, 2, 3, 4, 5];
    for (let i in array) {
        console.log(i);
    }
    // 0
    // 1
    // 2
    // 3
    // 4

For Of Loop

For of loop is used to iterate over iterable objects like arrays and strings.

    const array = [1, 2, 3, 4, 5];
    for (let i of array) {
        console.log(i);
    }
    // 1
    // 2
    // 3
    // 4
    // 5

For Each Loop

Traverse an array or object.

    const array = [1, 2, 3, 4, 5];
    array.forEach((element) => {
        console.log(element);
    })
    // 1
    // 2
    // 3
    // 4
    // 5

Map Loop

Map loops are used to iterate over arrays and objects.

    const array = [1, 2, 3, 4, 5];
    const newArray = array.map((element) => {
        return element * 2;
    }
    console.log(newArray);
    // [2, 4, 6, 8, 10]

Filter Loop

Returns a new array with all elements that pass the test implemented by the provided function.

    const array = [1, 2, 3, 4, 5];
    const newArray = array.filter((element) => {
        return element > 2;
    }
    console.log(newArray);
    // [3, 4, 5]

Reduce Loop

Reduce is a loop that takes an array and reduces it to a single value.

    const array = [1, 2, 3, 4, 5];
    const newArray = array.reduce((acc, element) => {
        return acc + element;
    }
    console.log(newArray);
    // 15

Find Loop

Returns the first element in the array that satisfies the provided testing function.

    const array = [1, 2, 3, 4, 5];
    const newArray = array.find((element) => {
        return element > 2;
    }
    console.log(newArray);
    // 3

Find Index Loop

Returns the index of the first element in the array that satisfies the provided testing function.

    const array = [1, 2, 3, 4, 5];
    const newArray = array.findIndex((element) => {
        return element > 2;
    }
    console.log(newArray);
    // 2

Every Loop

Returns true if all elements in the array pass the test. Or false if any element in the array fails the test.

    const array = [1, 2, 3, 4, 5];
    const newArray = array.every((element) => {
        return element > 2;
    }
    console.log(newArray);
    // false

Some Loop

Returns true if any element in the array pass the test. Or false if all elements in the array fail the test.

    const array = [1, 2, 3, 4, 5];
    const newArray = array.some((element) => {
        return element > 2;
    }
    console.log(newArray);
    // true

JavaScript Array Methods

Carlos Daniel Ortega Hernandez — Thu, 12 May 2022 00:34:33 +0000

Array Mutation Methods

Changes original array

pop(): Removes the las element of an array and returns it.

const array = ['Element 1', 'Element 2', 'Element 3'];
console.log(array.pop()); // 'Element 3'
console.log(array); // ['Element 1', 'Element 2'];

shift(): Removes the firts element of an array and returns it.

const array = ['Element 1', 'Element 2', 'Element 3'];
console.log(array.shift()); // 'Element 1'
console.log(array); // ['Element 2', 'Element 3'];

push(): Adds a new element to the array, at the end of the array, and returns the new length of the array.

const array = ['Element 1', 'Element 2', 'Element 3'];
console.log(array.push('Element 4')); // 4
console.log(array); // [ 'Element 1', 'Element 2', 'Element 3', 'Element 4' ]

reverse(): Reverses the order of the elements in an array.

const array = ['Element 1', 'Element 2', 'Element 3'];
console.log(array.reverse()); // [ 'Element 3', 'Element 2', 'Element 1' ]
console.log(array); // [ 'Element 3', 'Element 2', 'Element 1' ]

unshift(): Adds one or more elements to the beginning of an array, and returns the new length of the array.

const array = ['Element 1', 'Element 2', 'Element 3'];
console.log(array.unshift('Element 4')); // 4
console.log(array); // [ 'Element 4', 'Element 1', 'Element 2', 'Element 3' ]

sort(): Sorts the elements of an array.

const array = [2, 8, 1, 4];
console.log(array.sort()); // [ 1, 2, 4, 8 ]
console.log(array); // [ 1, 2, 4, 8 ]

splice(): Changes the contents of an array, removing existing elements and/or adds new elements.

const array = [2, 8, 1, 4, 'a', 'b'];
console.log(array.splice(1,3,'a')); // [ 8, 1, 4 ]
console.log(array); // [ 2, 'a', 'a', 'b' ]

Array Accessor Methods

Does not modify the original array. Creates new array.

join(): Joins all the elements of an array into a string and returns the string.

const array = [2, 8, 1, 4, 'a', 'b', 'c'];

console.log(array.join()); // '2,8,1,4,a,b,c'
console.log(array); // [ 2, 8, 1, 4, 'a', 'b', 'c' ]

slice(): Returns a part of the array in a new array.

const array = ['Element 1', 'Element 2', 'Element 3'];

console.log(array.slice(1, 2)); // [ 'Element 2' ]
console.log(array); // [ 'Element 1', 'Element 2', 'Element 3' ]

concat(): Joins two or more arrays into one.

const array = ['Element 1', 'Element 2', 'Element 3'];
const array2 = [1, 2, 3];
const array3 = [true, false];

console.log(array.concat(array2, array3)); // [ 'Element 1', 'Element 2', 'Element 3', 1, 2, 3, true, false ]
console.log(array); // [ 'Element 1', 'Element 2', 'Element 3' ]

includes(): Returns true if it finds the string, number, etc. or returns false if it finds nothing.

const array = ['Element 1', 'Element 2', 'Element 3'];

console.log(array.includes(2)); // false
console.log(array.includes('Element 1')); // true

toString(): Returns all elements of the array, in a string.

const array = ['Element 1', 'Element 2', 'Element 3'];

console.log(array.toString()); // 'Element 1,Element 2,Element 3'

indexOf(): Returns the first index that matches the search.

const array = [1, 2, 3, 4, 1, 3, 5, 2, 1];

console.log(array.indexOf(1)); // 0

lastIndexOf(): Returns the last index that matches the search.

const array = [1, 2, 3, 4, 1, 3, 5, 2, 1];

console.log(array.lastIndexOf(2)); // 7