Scribd
Upload
1 views

crud_node

Uploaded by

Leandro Lemos Lima
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
1 views

crud_node

Uploaded by

Leandro Lemos Lima
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

ChatGPT

Claro, vou te guiar através da criação de um CRUD básico em Node.js com PostgreSQL
e TypeScript, seguindo o padrão de arquitetura MVC (Model-View-Controller) com
serviços adicionados.

Vamos começar criando a estrutura de pastas e arquivos:

1. Criar uma pasta para o projeto e navegar até ela:

bash
Copiar código
mkdir nodejs-crud
cd nodejs-crud

2. Iniciar um projeto Node.js e configurar TypeScript:

bash
Copiar código
npm init -y
npm install typescript ts-node @types/node
npx tsc --init

3. Instalar as dependências necessárias:

bash
Copiar código
npm install express pg pg-promise body-parser

Agora, vamos criar a estrutura básica do nosso aplicativo:

plaintext
Copiar código
nodejs-crud/
│
├── src/
│ ├── controllers/
│ │ └── itemController.ts
│ │
│ ├── models/
│ │ └── itemModel.ts
│ │
│ ├── services/
│ │ └── itemService.ts
│ │
│ ├── routes/
│ │ └── itemRoutes.ts
│ │
│ ├── config.ts
│ ├── db.ts
│ ├── server.ts
│ └── types.ts
│
├── .gitignore
└── package.json
Agora, vamos preencher cada um desses arquivos com o código apropriado:

1. config.ts:

typescript
Copiar código
export const DB_CONFIG = {
host: 'localhost',
port: 5432,
database: 'crud_db',
user: 'postgres',
password: 'your_password_here',
};

2. db.ts:

typescript
Copiar código
import { DB_CONFIG } from './config';
import pgPromise from 'pg-promise';

const pgp = pgPromise();


const db = pgp(DB_CONFIG);

export default db;

3. types.ts:

typescript
Copiar código
export interface Item {
id?: number;
name: string;
description: string;
}

4. itemModel.ts:

typescript
Copiar código
import db from '../db';
import { Item } from '../types';

class ItemModel {
async getAllItems(): Promise<Item[]> {
return db.many('SELECT * FROM items');
}

async getItemById(id: number): Promise<Item | null> {


return db.oneOrNone('SELECT * FROM items WHERE id = $1', id);
}

async createItem(item: Item): Promise<Item> {


return db.one('INSERT INTO items(name, description) VALUES($1, $2)
RETURNING *', [
item.name,
item.description,
]);
}

async updateItem(id: number, item: Item): Promise<Item | null> {


return db.oneOrNone(
'UPDATE items SET name = $1, description = $2 WHERE id = $3
RETURNING *',
[item.name, item.description, id]
);
}

async deleteItem(id: number): Promise<void> {


await db.none('DELETE FROM items WHERE id = $1', id);
}
}

export default new ItemModel();

5. itemService.ts:

typescript
Copiar código
import itemModel from '../models/itemModel';
import { Item } from '../types';

class ItemService {
async getAllItems(): Promise<Item[]> {
return itemModel.getAllItems();
}

async getItemById(id: number): Promise<Item | null> {


return itemModel.getItemById(id);
}

async createItem(item: Item): Promise<Item> {


return itemModel.createItem(item);
}

async updateItem(id: number, item: Item): Promise<Item | null> {


return itemModel.updateItem(id, item);
}

async deleteItem(id: number): Promise<void> {


return itemModel.deleteItem(id);
}
}

export default new ItemService();

6. itemController.ts:

typescript
Copiar código
import { Request, Response } from 'express';
import itemService from '../services/itemService';
import { Item } from '../types';

class ItemController {
async getAllItems(req: Request, res: Response): Promise<void> {
const items = await itemService.getAllItems();
res.json(items);
}

async getItemById(req: Request, res: Response): Promise<void> {


const id = parseInt(req.params.id);
const item = await itemService.getItemById(id);
if (item) {
res.json(item);
} else {
res.status(404).json({ message: 'Item not found' });
}
}

async createItem(req: Request, res: Response): Promise<void> {


const newItem: Item = req.body;
const createdItem = await itemService.createItem(newItem);
res.status(201).json(createdItem);
}

async updateItem(req: Request, res: Response): Promise<void> {


const id = parseInt(req.params.id);
const updatedItem: Item = req.body;
const item = await itemService.updateItem(id, updatedItem);
if (item) {
res.json(item);
} else {
res.status(404).json({ message: 'Item not found' });
}
}

async deleteItem(req: Request, res: Response): Promise<void> {


const id = parseInt(req.params.id);
await itemService.deleteItem(id);
res.sendStatus(204);
}
}

export default new ItemController();

7. itemRoutes.ts:

typescript
Copiar código
import express from 'express';
import itemController from '../controllers/itemController';

const router = express.Router();

router.get('/', itemController.getAllItems);
router.get('/:id', itemController.getItemById);
router.post('/', itemController.createItem);
router.put('/:id', itemController.updateItem);
router.delete('/:id', itemController.deleteItem);

export default router;

8. server.ts:

typescript
Copiar código
import express, { Application, Request, Response } from 'express';
import bodyParser from 'body-parser';
import itemRoutes from './routes/itemRoutes';

const app: Application = express();


const PORT = 3000;

// Middleware
app.use(bodyParser.json());

// Routes
app.use('/items', itemRoutes);

// Error handler
app.use((err: any, req: Request, res: Response, next: Function) => {
console.error(err.stack);
res.status(500).send('Something broke!');
});

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

You might also like