---
# System prepended metadata

title: 'Generated API Client - ja nein vielleicht, wie?'

---

## Generated API Client

Das hat alles wenig bis nichts mit Strapi zu tun -> das ist der typescript-axios generator

Git Issue - pass request params as object: https://github.com/OpenAPITools/openapi-generator/issues/5385 


### Was ich dachte, wie der intended use ist:
````typescript
export const userOfferService = UserOfferApiFactory(configuration);
````
und dann in den Components so aufrufen:
````typescript
userOfferService.getOffers(requestOptions)
````

Problem:
Die `getOffers` Methode übernimmt kein Options Objekt sondern man müsste die Options so übergeben:

````typescript
userOfferService.getUserOffers(
        sort,
        paginationWithCount,
        paginationPage,
        paginationPageSize,
        paginationStart,
        paginationLimit,
        fields,
        populate,
        filters,
        locale,
        options,
      );
````

Was ein absoluter Müll ist, weil wenn ich nur einen filter übergeben will schaut das ganze so aus (bzw. geht eh nicht weil undefined nicht mit dem typ zusammenpasst):

````typescript
userOfferService.getUserOffers(
        undefined,
        undefined,
        undefined,
        undefined,
        undefined,
        undefined,
        undefined,
        undefined,
        {filter},
        undefined,
        undefined,
      );
````

### Was ich jetzt glaube der intented use ist:

Config mit den Request options muss schon an die Api Factory übergeben werden, weil

1. ApiFactory erstellt mit der Config ein functional programming interface ApiFp, dass..
2. die config an ApiAxiosParamCreator weitergibt , der...
3. aus der Config die queryParams für den Request setzt

eg:
````typescript
// component.tsx
const config = new Configuration({
        baseOptions: {
          filters: getUserOfferFilter,
        },
      });

const userOfferApi = UserOfferApiFactory(configuration);

const offers = userOfferApi.getOffers()
````
im generierten client:
````typescript
// API Factory
export const UserOfferApiFactory = function (
  configuration?: Configuration,
  basePath?: string,
  axios?: AxiosInstance,
) {
  const localVarFp = UserOfferApiFp(configuration);
    return ...
}

// API Functional Programming Interface
export const UserOfferApiFp = function (configuration?: Configuration) {
  const localVarAxiosParamCreator =
    UserOfferApiAxiosParamCreator(configuration);
    return ...
}
    
// ApiAxiosParamCreator
getUserOffers: async (
      sort?: string,
      paginationWithCount?: boolean,
      paginationPage?: number,
      paginationPageSize?: number,
      paginationStart?: number,
      paginationLimit?: number,
      fields?: string,
      populate?: string,
      filters?: object,
      locale?: string,
      options: RawAxiosRequestConfig = {},
    ): Promise<RequestArgs> => {
      
      let baseOptions;
      if (configuration) {
        baseOptions = configuration.baseOptions;
      } 
        return...
}
````

**Bedeutet:**
Dass ich für jeden Request eine eigenen Aufruf an API Factory machen muss, oder? Ist das nicht schirch? Weil die Factory mir jedes mal alle Methoden (getById, getAll, post, delete) returned ich aber jeweils nur eine brauch.

e.g., 

````typescript
// userOffersService.ts

// getAll
const getUserOffersConfig = new Configuration({
        baseOptions: {
          filters: getUserOfferFilter,
        },
      });

const getUserOffers = UserOfferApiFactory(getUserOffersConfig).getUserOffers();


// create
const postUserOffersConfig = new Configuration({
        baseOptions: {
          // post Options
        },
      });

const postUserOffers = (userOffer) => UserOfferApiFactory(postUserOffersConfig).postUserOffers(userOffer);

...
````

Alternativ, kann man auch direkt auf den `ParamCreator` zugreifen um eigene Requests zu schreiben, aber dann is wieder die Frage, ob der Client überhaupt generiert werden soll, weil die generierten Types auch nicht ganz mit den Responses zusammenpassen (zumindest für die Custom Enpoints*)

**Diskurs Custom Endpoints:* OpenAPI bezieht nicht mit ein was in Controllern oder Services passiert, daher werden die response types von überschriebenen Methoden nicht richtig mitgeneriert. Ich kann natürlich die responses im Controller anpassen, damit sie die gleiche Form haben, wie die von Strapi, wo dann wieder die Frage ist, ob wir das wollen. 
weil die schon etwas zu sehr geschachtelt sind für meinen Geschmack. 

![image](https://hackmd.io/_uploads/ryq3dR19T.png)

Und im Frontend schöne Aufrufe verursachen wie 
````typescript
const offers: Offer[] = response.data.data.data as Offer[]
````

### Fragen
* Sollen wir den Client wirklich generieren?
* Kann man irgendwo in Strapi die Types/Methoden anpassen (Sodass sie nciht beim nächsten mal generiern überschrieben werden) (ich glaube nicht)?
* Soll im Fronend eine Mittelschicht eingezogen werden, die den generierten Client verwenden aber types und methoden überschreiben (ich weiß nicht, ob sich das auszahlt)?