ngx-restful-client/README.md

The ultimate Angular library to exquisitely declare and implement the REST APIs you'll use in your application.

# ngx-restful-client
- ### [ptBR] A biblioteca Angular definitiva para declarar e implementar primorosamente as APIs REST que você usará na sua aplicação.
- ### [en] The ultimate Angular library to exquisitely declare and implement the REST APIs you'll use in your application.
<img alt="Angular" src="https://shields.io/badge/Angular-red?&style=plastic&logo=angular&label=|">

### TL;DR
- ### [ptBR] Requisite sua API de forma fácil e coesa na sua aplicação sem a necessidade de declarar suas URIs e URLs concatenando-as em toda chamada.
  - Aprenda mais sobre as [convenções de nomenclaturas em uma API RESTful](https://restfulapi.net/resource-naming/)
- ### [en] Request your API easily and cohesively in your application without having to declare your URIs and URLs by concatenating them in every call.
  - Learn more about [RESTful API resource naming conventions](https://restfulapi.net/resource-naming/)
### Sample of how to use the library
- API

```ts
import {RestApi} from "./rest-api";
import {HttpClient} from "@angular/common/http";

@Injectable({providedIn: "root"})
export class BookstoreApi extends RestApi {
  readonly books = new BooksResource(this);
  readonly authors = new AuthorsResource(this);

  constructor(http: HttpClient) {
    super(http, 'http://api.bookstore.com/v1');
  }

  /**
   * Override this method if you need to dinamically add the Authorization header when needed
   */
  get guard(): BookstoreApi {
    return super.guard as any;
  }

  /**
   * Override this method if you need to dinamically remove the Authorization header when needed
   */
  get unguard(): BookstoreApi {
    return super.guard as any;
  }

  /**
   * Override this method to provide the Authorization header content
   */
  get authorization(): string {
    return `Bearer ${localStorage.getItem('token')}`;
  }
}
```
- Resources
> BooksResource
```ts
import {ReferenceableResource} from "./referenceable-resource";
import {ReferencedResource} from "./referenced-resource";
import {RestResource} from "./rest-resource";

export class BooksResource extends ReferenceableResource<BooksCollection> {
  constructor(parent: RestResource) {
    super('/books', parent, p => new BooksCollection(p));
  }
}

class BooksCollection extends ReferencedResource {
  readonly authors = new AuthorsResource(this);
}


```
> AuthorsResource

```ts
import {ReferenceableResource} from "./referenceable-resource";
import {ReferencedResource} from "./referenced-resource";
import {createDefaultResource} from "./index";

export class AuthorsResource extends ReferenceableResource<AuthorsCollection> {
  constructor(parent: RestfulResource) {
    super(parent, '/authors', p => new AuthorsCollection(p));
  }
}

export class AuthorsCollection extends ReferencedResource {
  /**
   * Get the books of a specific author
   */
  readonly books = new BooksResource(this);
  /**
   * May get movies produced based on the author's work
   */
  readonly movies = createDefaultResource('/movies');
}
```

- Service
> ExploreAuthorsService
```ts
@Injectable({providedIn: "root"})
export class ExploreAuthorsService {
  constructor(private readonly api: BookstoreApi) {
  }

  saveNewAuthor(author: Author): Observable<Author> {
    return this.api.authors.post<Author>(author);
  }

  updateExistingAuthor(author: Author): Observable<Author> {
    return this.api.authors.put<Author>(author);
  }

  deleteAuthor(id: number): Observable<unknown> {
    return this.api.authors.id(id).delete();
  }

  getAuthorById(id: number): Observable<Author> {
    return this.api.authors.id(id).get<Author>();
  }

  filterAuthors(filter?: AuthorFilter): Observable<Author[]> {
    return this.api.authors.get<Author[]>(() => filter);
  }

  getBooksByAuthorId(authorId: number): Observable<Book[]> {
    return this.api.authors.id(authorId).books.get<Book[]>();
  }

  getMoviesByAuthorId(authorId: number): Observable<any[]> {
    return this.api.authors.id(authorId).movies.get();
  }

}
```
- Component
> AppComponent
```ts
@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss']
})
export class AppComponent {
  constructor(readonly service: ExploreAuthorsService) {
    this.execute();
  }
  execute(): void {
    this.service.getBooks(1).pipe(take(1)).subscribe(b => logger.info('Books of author: ', b));
    this.service.filterAuthors({name: 'John'}).pipe(take(1)).subscribe(b => logger.info('Authors found: ', b));
    this.service.getMovies(2).pipe(take(1)).subscribe(b => logger.info('Movies found: ', b));
  }
}
```