Nest.js troubleshooting

Question

Nest.js troubleshooting

Samir ⚽⚽⚽ 0

I need some basic frontend to this code in nest.js my backend looks like this:

nestjs controller: @Controller('authors')

export class AuthorsController {

constructor(

    private readonly authorsService: AuthorsService

) {}

@Get() 

getAuthors() {

    return this.authorsService.getAuthors();

}

@Get('/:id')

getAuthor(

    @Param('id') authorId: number

): Promise<Author> {

    return this.authorsService.getAuthor(authorId);

}

@Post()

createAuthor(

    @Body() authorDto: AuthorDto

): Promise<Author> {

    return this.authorsService.createAuthor(authorDto);

}

@Put('/:id')

editAuthor(

    @Param('id') authorId: number,

    @Body() authorDto: AuthorDto

): Promise<Author> {

    return this.authorsService.editAuthor(authorId,authorDto);

}

@Delete('/:id')

deleteAuthor(

    @Param('id') authorId: number

): Promise<Author> {

    return this.authorsService.deleteAuthor(authorId);

}

}

SERVICE

nestjs service: @Injectable()

export class BooksService {

constructor(

    @InjectRepository(Book)

    private booksRepository: Repository<Book>

) {}

getBooks(): Promise<Book[]> {

    return this.booksRepository.find({

        relations: ['author'],

    });

}

getBook(id: number): Promise<Book> {

    return this.booksRepository.findOne( { 

        where: { id },

        relations: ['author'],

    });

}

async createBook(data: BookDto): Promise<Book>  {

    const book = this.booksRepository.create({

        ...data,

        author: { id: data.authorId},

    });

    return this.booksRepository.save(book);

}

async editBook(id: number, data: BookDto): Promise<Book> {

    const book = await this.booksRepository.findOne({

        where: { id },

        relations: ['author'],

    });

    if(!book) {

        throw new NotFoundException('Book does not exist');

    }

    book.author = new Author();

    book.author.id = data.authorId;

    book.title = data.title;

    book.year = data.year;

    return this.booksRepository.save(book);

}

async deleteBook(id: number): Promise<Book> {

    const book = await this.booksRepository.findOne({ where: {id} });

    if(!book) {

        throw new NotFoundException('Book does not exists');

    }

    return this.booksRepository.remove(book);

}

}

MODULE

nestjs module: @Module({

imports: [

    TypeOrmModule.forFeature([Book])

],

controllers: [BooksController],

providers: [BooksService],

})

export class BooksModule {}

ENTITY

nestjs entity: @Entity()

export class Book {

@PrimaryGeneratedColumn()

id:number;

@ManyToOne(

    type => Author,

    a => a.books,

)

author: Author;

@Column()

title: string;

@Column()

year: number;

}

Max 0

FRONTEND will propably look like thisNESTJS fetch.js, GET, POST, PUT, DELETE:

// Načte všechny knihy

async function fetchBooks() {

try {

    const response = await fetch('http://localhost:3000/books');

    if (!response.ok) throw new Error('Chyba při načítání knih');

    const books = await response.json();

    // Voláme zvlášť autory

    const authorsResponse = await fetch('http://localhost:3000/authors');

    if (!authorsResponse.ok) throw new Error('Chyba při načítání autorů');

    const authors = await authorsResponse.json();

    const tableBody = document.querySelector('#books-table tbody');

    tableBody.innerHTML = '';

    books.forEach(book => {

        const author = authors.find(a => a.id === book.authorId);

        const authorName = author ? author.name : 'Neznámý autor';

        const row = document.createElement('tr');

        row.innerHTML = 

            <td>${book.title}</td>

            <td>${book.year}</td>

            <td>${book.author.name}</td>

            <td>

                <button class="edit-btn" onclick="editBook(${book.id})">Edit</button>

                <button class="remove-btn" onclick="deleteBook(${book.id})">Remove</button>

            </td>

        ;

        tableBody.appendChild(row);

    });

} catch (error) {

    console.error('Chyba při načítání knih:', error);

}

}

async function loadAuthorsIntoSelect(selectedAuthorId = null) {

try {

    const response = await fetch('http://localhost:3000/authors');

    if (!response.ok) throw new Error('Chyba při načítání autorů');

    const authors = await response.json();

    const select = document.getElementById('book-authorId');

    select.innerHTML = '';

    authors.forEach(author => {

        const option = document.createElement('option');

        option.value = author.id;

        option.textContent = author.name;

        if (selectedAuthorId && selectedAuthorId == author.id) {

            option.selected = true;

        }

        select.appendChild(option);

    });

} catch (error) {

    console.error('Chyba při načítání autorů:', error);

}

}

async function openBookForm(book = null) {

document.querySelector('.form-popup').style.display = 'block';

await loadAuthorsIntoSelect(book ? book.authorId : null);

if (book) {

    document.getElementById('book-id').value = book.id;

    document.getElementById('book-title').value = book.title;

    document.getElementById('book-year').value = book.year;

} else {

    document.getElementById('book-id').value = '';

    document.getElementById('book-title').value = '';

    document.getElementById('book-year').value = '';

}

}

function closeBookForm() {

document.querySelector('.form-popup').style.display = 'none';

}

// Klik na tlačítko "Create Book"

document.getElementById('create-book').addEventListener('click', () => openBookForm());

// Submit formuláře

document.getElementById('book-form').addEventListener('submit', async function (event) {

event.preventDefault();

const id = document.getElementById('book-id').value;

const title = document.getElementById('book-title').value;

const year = document.getElementById('book-year').value;

const authorId = document.getElementById('book-authorId').value;

const bookData = { title, year, authorId };

try {

    if (id) {

        // EDIT

        const response = await fetch(http://localhost:3000/books/${id}, {

            method: 'PUT',

            headers: { 'Content-Type': 'application/json' },

            body: JSON.stringify(bookData)

        });

        if (!response.ok) throw new Error('Chyba při úpravě knihy');

    } else {

        // CREATE

        const response = await fetch('http://localhost:3000/books', {

            method: 'POST',

            headers: { 'Content-Type': 'application/json' },

            body: JSON.stringify(bookData)

        });

        if (!response.ok) throw new Error('Chyba při vytváření knihy');

    }

    closeBookForm();

    fetchBooks();

} catch (error) {

    console.error(error);

}

});

async function editBook(id) {

try {

    const response = await fetch(http://localhost:3000/books/${id});

    if (!response.ok) throw new Error('Chyba při načítání knihy');

    const book = await response.json();

    openBookForm(book);

} catch (error) {

    console.error(error);

}

}

// Funkce pro kliknutí na "Remove"

async function deleteBook(id) {

if (!confirm('Opravdu chcete tuto knihu smazat?')) return;

try {

    const response = await fetch(http://localhost:3000/books/${id}, {

        method: 'DELETE'

    });

    if (!response.ok) throw new Error('Chyba při mazání knihy');

    fetchBooks();

} catch (error) {

    console.error(error);

}

}

// Načte knihy při načtení stránky

window.onload = fetchBooks;

Samir ⚽⚽⚽ 0 Reputation points

2025-04-28T20:36:13.7433333+00:00

import { IsString, IsNotEmpty } from 'class-validator';

export class AuthorDto {

@IsString()

@IsNotEmpty()

name: string;

}

import { IsString, IsInt, IsNotEmpty } from 'class-validator';

export class BookDto {

@IsInt()

@IsNotEmpty()

authorId: number;

@IsString()

@IsNotEmpty()

title: string;

@IsInt()

@IsNotEmpty()

year: number;

}

Your answer

Samir ⚽⚽⚽ 0 Reputation points

2025-04-28T20:36:13.7433333+00:00

import { IsString, IsNotEmpty } from 'class-validator';

export class AuthorDto {

@IsString()

@IsNotEmpty()

name: string;

}

import { IsString, IsInt, IsNotEmpty } from 'class-validator';

export class BookDto {

@IsInt()

@IsNotEmpty()

authorId: number;

@IsString()

@IsNotEmpty()

title: string;

@IsInt()

@IsNotEmpty()

year: number;

}

Share via

Nest.js troubleshooting

Your answer