@squonk/account-server-client 0.1.27-rc.1 → 0.1.28-rc.1

package/src/product/product.ts

@@ -8,7 +8,6 @@ A service that provides access to the Account Server, which gives *registered* u
 
  * OpenAPI spec version: 0.1
  */
-import axios, { AxiosRequestConfig, AxiosResponse, AxiosError } from "axios";
 import {
   useQuery,
   useMutation,
@@ -28,6 +27,7 @@ import type {
   ProductUnitGetResponse,
   ProductPatchBodyBody,
 } from "../account-server-api.schemas";
+import { customInstance, ErrorType } from ".././custom-instance";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (
@@ -36,45 +36,55 @@ type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (
   ? R
   : any;
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type SecondParameter<T extends (...args: any) => any> = T extends (
+  config: any,
+  args: infer P
+) => any
+  ? P
+  : never;
+
 /**
  * Gets product types you can purchase
 
  * @summary Gets all Product Types
  */
-export const appApiProductGetTypes = (
-  options?: AxiosRequestConfig
-): Promise<AxiosResponse<ProductsGetTypesResponse>> => {
-  return axios.get(`/product-type`, options);
+export const getProductTypes = (
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ProductsGetTypesResponse>(
+    { url: `/product-type`, method: "get" },
+    options
+  );
 };
 
-export const getAppApiProductGetTypesQueryKey = () => [`/product-type`];
+export const getGetProductTypesQueryKey = () => [`/product-type`];
 
-export type AppApiProductGetTypesQueryResult = NonNullable<
-  AsyncReturnType<typeof appApiProductGetTypes>
+export type GetProductTypesQueryResult = NonNullable<
+  AsyncReturnType<typeof getProductTypes>
 >;
-export type AppApiProductGetTypesQueryError = AxiosError<AsError | void>;
+export type GetProductTypesQueryError = ErrorType<AsError | void>;
 
-export const useAppApiProductGetTypes = <
-  TData = AsyncReturnType<typeof appApiProductGetTypes>,
-  TError = AxiosError<AsError | void>
+export const useGetProductTypes = <
+  TData = AsyncReturnType<typeof getProductTypes>,
+  TError = ErrorType<AsError | void>
 >(options?: {
   query?: UseQueryOptions<
-    AsyncReturnType<typeof appApiProductGetTypes>,
+    AsyncReturnType<typeof getProductTypes>,
     TError,
     TData
   >;
-  axios?: AxiosRequestConfig;
+  request?: SecondParameter<typeof customInstance>;
 }): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
-  const { query: queryOptions, axios: axiosOptions } = options || {};
+  const { query: queryOptions, request: requestOptions } = options || {};
 
-  const queryKey = queryOptions?.queryKey ?? getAppApiProductGetTypesQueryKey();
+  const queryKey = queryOptions?.queryKey ?? getGetProductTypesQueryKey();
 
-  const queryFn: QueryFunction<
-    AsyncReturnType<typeof appApiProductGetTypes>
-  > = () => appApiProductGetTypes(axiosOptions);
+  const queryFn: QueryFunction<AsyncReturnType<typeof getProductTypes>> = () =>
+    getProductTypes(requestOptions);
 
   const query = useQuery<
-    AsyncReturnType<typeof appApiProductGetTypes>,
+    AsyncReturnType<typeof getProductTypes>,
     TError,
     TData
   >(queryKey, queryFn, queryOptions);
@@ -90,42 +100,41 @@ export const useAppApiProductGetTypes = <
 
  * @summary Gets all Products
  */
-export const appApiProductGet = (
-  options?: AxiosRequestConfig
-): Promise<AxiosResponse<ProductsGetResponse>> => {
-  return axios.get(`/product`, options);
+export const getProducts = (
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ProductsGetResponse>(
+    { url: `/product`, method: "get" },
+    options
+  );
 };
 
-export const getAppApiProductGetQueryKey = () => [`/product`];
+export const getGetProductsQueryKey = () => [`/product`];
 
-export type AppApiProductGetQueryResult = NonNullable<
-  AsyncReturnType<typeof appApiProductGet>
+export type GetProductsQueryResult = NonNullable<
+  AsyncReturnType<typeof getProducts>
 >;
-export type AppApiProductGetQueryError = AxiosError<AsError | void>;
+export type GetProductsQueryError = ErrorType<AsError | void>;
 
-export const useAppApiProductGet = <
-  TData = AsyncReturnType<typeof appApiProductGet>,
-  TError = AxiosError<AsError | void>
+export const useGetProducts = <
+  TData = AsyncReturnType<typeof getProducts>,
+  TError = ErrorType<AsError | void>
 >(options?: {
-  query?: UseQueryOptions<
-    AsyncReturnType<typeof appApiProductGet>,
-    TError,
-    TData
-  >;
-  axios?: AxiosRequestConfig;
+  query?: UseQueryOptions<AsyncReturnType<typeof getProducts>, TError, TData>;
+  request?: SecondParameter<typeof customInstance>;
 }): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
-  const { query: queryOptions, axios: axiosOptions } = options || {};
+  const { query: queryOptions, request: requestOptions } = options || {};
 
-  const queryKey = queryOptions?.queryKey ?? getAppApiProductGetQueryKey();
+  const queryKey = queryOptions?.queryKey ?? getGetProductsQueryKey();
 
-  const queryFn: QueryFunction<AsyncReturnType<typeof appApiProductGet>> = () =>
-    appApiProductGet(axiosOptions);
+  const queryFn: QueryFunction<AsyncReturnType<typeof getProducts>> = () =>
+    getProducts(requestOptions);
 
-  const query = useQuery<
-    AsyncReturnType<typeof appApiProductGet>,
-    TError,
-    TData
-  >(queryKey, queryFn, queryOptions);
+  const query = useQuery<AsyncReturnType<typeof getProducts>, TError, TData>(
+    queryKey,
+    queryFn,
+    queryOptions
+  );
 
   return {
     queryKey,
@@ -136,49 +145,53 @@ export const useAppApiProductGet = <
 /**
  * @summary Creates a Product for an Organisational Unit
  */
-export const appApiProductPost = (
+export const createUnitProduct = (
   unitId: string,
   unitProductPostBodyBody: UnitProductPostBodyBody,
-  options?: AxiosRequestConfig
-): Promise<AxiosResponse<UnitProductPostResponse>> => {
-  return axios.post(
-    `/product/unit/${unitId}`,
-    unitProductPostBodyBody,
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<UnitProductPostResponse>(
+    {
+      url: `/product/unit/${unitId}`,
+      method: "post",
+      headers: { "Content-Type": "application/json" },
+      data: unitProductPostBodyBody,
+    },
     options
   );
 };
 
-export type AppApiProductPostMutationResult = NonNullable<
-  AsyncReturnType<typeof appApiProductPost>
+export type CreateUnitProductMutationResult = NonNullable<
+  AsyncReturnType<typeof createUnitProduct>
 >;
-export type AppApiProductPostMutationBody = UnitProductPostBodyBody;
-export type AppApiProductPostMutationError = AxiosError<AsError | void>;
+export type CreateUnitProductMutationBody = UnitProductPostBodyBody;
+export type CreateUnitProductMutationError = ErrorType<AsError | void>;
 
-export const useAppApiProductPost = <
-  TError = AxiosError<AsError | void>,
+export const useCreateUnitProduct = <
+  TError = ErrorType<AsError | void>,
   TContext = unknown
 >(options?: {
   mutation?: UseMutationOptions<
-    AsyncReturnType<typeof appApiProductPost>,
+    AsyncReturnType<typeof createUnitProduct>,
     TError,
     { unitId: string; data: UnitProductPostBodyBody },
     TContext
   >;
-  axios?: AxiosRequestConfig;
+  request?: SecondParameter<typeof customInstance>;
 }) => {
-  const { mutation: mutationOptions, axios: axiosOptions } = options || {};
+  const { mutation: mutationOptions, request: requestOptions } = options || {};
 
   const mutationFn: MutationFunction<
-    AsyncReturnType<typeof appApiProductPost>,
+    AsyncReturnType<typeof createUnitProduct>,
     { unitId: string; data: UnitProductPostBodyBody }
   > = (props) => {
     const { unitId, data } = props || {};
 
-    return appApiProductPost(unitId, data, axiosOptions);
+    return createUnitProduct(unitId, data, requestOptions);
   };
 
   return useMutation<
-    AsyncReturnType<typeof appApiProductPost>,
+    AsyncReturnType<typeof createUnitProduct>,
     TError,
     { unitId: string; data: UnitProductPostBodyBody },
     TContext
@@ -189,47 +202,50 @@ export const useAppApiProductPost = <
 
  * @summary Gets Products for an Organisational Unit
  */
-export const appApiProductGetForUnit = (
+export const getProductsForUnit = (
   unitId: string,
-  options?: AxiosRequestConfig
-): Promise<AxiosResponse<ProductsGetResponse>> => {
-  return axios.get(`/product/unit/${unitId}`, options);
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ProductsGetResponse>(
+    { url: `/product/unit/${unitId}`, method: "get" },
+    options
+  );
 };
 
-export const getAppApiProductGetForUnitQueryKey = (unitId: string) => [
+export const getGetProductsForUnitQueryKey = (unitId: string) => [
   `/product/unit/${unitId}`,
 ];
 
-export type AppApiProductGetForUnitQueryResult = NonNullable<
-  AsyncReturnType<typeof appApiProductGetForUnit>
+export type GetProductsForUnitQueryResult = NonNullable<
+  AsyncReturnType<typeof getProductsForUnit>
 >;
-export type AppApiProductGetForUnitQueryError = AxiosError<void | AsError>;
+export type GetProductsForUnitQueryError = ErrorType<void | AsError>;
 
-export const useAppApiProductGetForUnit = <
-  TData = AsyncReturnType<typeof appApiProductGetForUnit>,
-  TError = AxiosError<void | AsError>
+export const useGetProductsForUnit = <
+  TData = AsyncReturnType<typeof getProductsForUnit>,
+  TError = ErrorType<void | AsError>
 >(
   unitId: string,
   options?: {
     query?: UseQueryOptions<
-      AsyncReturnType<typeof appApiProductGetForUnit>,
+      AsyncReturnType<typeof getProductsForUnit>,
       TError,
       TData
     >;
-    axios?: AxiosRequestConfig;
+    request?: SecondParameter<typeof customInstance>;
   }
 ): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
-  const { query: queryOptions, axios: axiosOptions } = options || {};
+  const { query: queryOptions, request: requestOptions } = options || {};
 
   const queryKey =
-    queryOptions?.queryKey ?? getAppApiProductGetForUnitQueryKey(unitId);
+    queryOptions?.queryKey ?? getGetProductsForUnitQueryKey(unitId);
 
   const queryFn: QueryFunction<
-    AsyncReturnType<typeof appApiProductGetForUnit>
-  > = () => appApiProductGetForUnit(unitId, axiosOptions);
+    AsyncReturnType<typeof getProductsForUnit>
+  > = () => getProductsForUnit(unitId, requestOptions);
 
   const query = useQuery<
-    AsyncReturnType<typeof appApiProductGetForUnit>,
+    AsyncReturnType<typeof getProductsForUnit>,
     TError,
     TData
   >(queryKey, queryFn, { enabled: !!unitId, ...queryOptions });
@@ -245,54 +261,50 @@ export const useAppApiProductGetForUnit = <
 
  * @summary Gets a Unit's Product
  */
-export const appApiProductGetUnitProduct = (
+export const getProduct = (
   unitId: string,
   productId: string,
-  options?: AxiosRequestConfig
-): Promise<AxiosResponse<ProductUnitGetResponse>> => {
-  return axios.get(`/product/unit/${unitId}/product/${productId}`, options);
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ProductUnitGetResponse>(
+    { url: `/product/unit/${unitId}/product/${productId}`, method: "get" },
+    options
+  );
 };
 
-export const getAppApiProductGetUnitProductQueryKey = (
-  unitId: string,
-  productId: string
-) => [`/product/unit/${unitId}/product/${productId}`];
+export const getGetProductQueryKey = (unitId: string, productId: string) => [
+  `/product/unit/${unitId}/product/${productId}`,
+];
 
-export type AppApiProductGetUnitProductQueryResult = NonNullable<
-  AsyncReturnType<typeof appApiProductGetUnitProduct>
+export type GetProductQueryResult = NonNullable<
+  AsyncReturnType<typeof getProduct>
 >;
-export type AppApiProductGetUnitProductQueryError = AxiosError<AsError | void>;
+export type GetProductQueryError = ErrorType<AsError | void>;
 
-export const useAppApiProductGetUnitProduct = <
-  TData = AsyncReturnType<typeof appApiProductGetUnitProduct>,
-  TError = AxiosError<AsError | void>
+export const useGetProduct = <
+  TData = AsyncReturnType<typeof getProduct>,
+  TError = ErrorType<AsError | void>
 >(
   unitId: string,
   productId: string,
   options?: {
-    query?: UseQueryOptions<
-      AsyncReturnType<typeof appApiProductGetUnitProduct>,
-      TError,
-      TData
-    >;
-    axios?: AxiosRequestConfig;
+    query?: UseQueryOptions<AsyncReturnType<typeof getProduct>, TError, TData>;
+    request?: SecondParameter<typeof customInstance>;
   }
 ): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
-  const { query: queryOptions, axios: axiosOptions } = options || {};
+  const { query: queryOptions, request: requestOptions } = options || {};
 
   const queryKey =
-    queryOptions?.queryKey ??
-    getAppApiProductGetUnitProductQueryKey(unitId, productId);
+    queryOptions?.queryKey ?? getGetProductQueryKey(unitId, productId);
 
-  const queryFn: QueryFunction<
-    AsyncReturnType<typeof appApiProductGetUnitProduct>
-  > = () => appApiProductGetUnitProduct(unitId, productId, axiosOptions);
+  const queryFn: QueryFunction<AsyncReturnType<typeof getProduct>> = () =>
+    getProduct(unitId, productId, requestOptions);
 
-  const query = useQuery<
-    AsyncReturnType<typeof appApiProductGetUnitProduct>,
-    TError,
-    TData
-  >(queryKey, queryFn, { enabled: !!(unitId && productId), ...queryOptions });
+  const query = useQuery<AsyncReturnType<typeof getProduct>, TError, TData>(
+    queryKey,
+    queryFn,
+    { enabled: !!(unitId && productId), ...queryOptions }
+  );
 
   return {
     queryKey,
@@ -303,45 +315,48 @@ export const useAppApiProductGetUnitProduct = <
 /**
  * @summary Deletes an existing Product
  */
-export const appApiProductDelete = (
+export const deleteProduct = (
   unitId: string,
   productId: string,
-  options?: AxiosRequestConfig
-): Promise<AxiosResponse<void>> => {
-  return axios.delete(`/product/unit/${unitId}/product/${productId}`, options);
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<void>(
+    { url: `/product/unit/${unitId}/product/${productId}`, method: "delete" },
+    options
+  );
 };
 
-export type AppApiProductDeleteMutationResult = NonNullable<
-  AsyncReturnType<typeof appApiProductDelete>
+export type DeleteProductMutationResult = NonNullable<
+  AsyncReturnType<typeof deleteProduct>
 >;
 
-export type AppApiProductDeleteMutationError = AxiosError<AsError>;
+export type DeleteProductMutationError = ErrorType<AsError>;
 
-export const useAppApiProductDelete = <
-  TError = AxiosError<AsError>,
+export const useDeleteProduct = <
+  TError = ErrorType<AsError>,
   TContext = unknown
 >(options?: {
   mutation?: UseMutationOptions<
-    AsyncReturnType<typeof appApiProductDelete>,
+    AsyncReturnType<typeof deleteProduct>,
     TError,
     { unitId: string; productId: string },
     TContext
   >;
-  axios?: AxiosRequestConfig;
+  request?: SecondParameter<typeof customInstance>;
 }) => {
-  const { mutation: mutationOptions, axios: axiosOptions } = options || {};
+  const { mutation: mutationOptions, request: requestOptions } = options || {};
 
   const mutationFn: MutationFunction<
-    AsyncReturnType<typeof appApiProductDelete>,
+    AsyncReturnType<typeof deleteProduct>,
     { unitId: string; productId: string }
   > = (props) => {
     const { unitId, productId } = props || {};
 
-    return appApiProductDelete(unitId, productId, axiosOptions);
+    return deleteProduct(unitId, productId, requestOptions);
   };
 
   return useMutation<
-    AsyncReturnType<typeof appApiProductDelete>,
+    AsyncReturnType<typeof deleteProduct>,
     TError,
     { unitId: string; productId: string },
     TContext
@@ -352,50 +367,54 @@ export const useAppApiProductDelete = <
 
  * @summary Adjust an existing Product
  */
-export const appApiProductPatch = (
+export const patchProduct = (
   unitId: string,
   productId: string,
   productPatchBodyBody: ProductPatchBodyBody,
-  options?: AxiosRequestConfig
-): Promise<AxiosResponse<void>> => {
-  return axios.patch(
-    `/product/unit/${unitId}/product/${productId}`,
-    productPatchBodyBody,
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<void>(
+    {
+      url: `/product/unit/${unitId}/product/${productId}`,
+      method: "patch",
+      headers: { "Content-Type": "application/json" },
+      data: productPatchBodyBody,
+    },
     options
   );
 };
 
-export type AppApiProductPatchMutationResult = NonNullable<
-  AsyncReturnType<typeof appApiProductPatch>
+export type PatchProductMutationResult = NonNullable<
+  AsyncReturnType<typeof patchProduct>
 >;
-export type AppApiProductPatchMutationBody = ProductPatchBodyBody;
-export type AppApiProductPatchMutationError = AxiosError<AsError>;
+export type PatchProductMutationBody = ProductPatchBodyBody;
+export type PatchProductMutationError = ErrorType<AsError>;
 
-export const useAppApiProductPatch = <
-  TError = AxiosError<AsError>,
+export const usePatchProduct = <
+  TError = ErrorType<AsError>,
   TContext = unknown
 >(options?: {
   mutation?: UseMutationOptions<
-    AsyncReturnType<typeof appApiProductPatch>,
+    AsyncReturnType<typeof patchProduct>,
     TError,
     { unitId: string; productId: string; data: ProductPatchBodyBody },
     TContext
   >;
-  axios?: AxiosRequestConfig;
+  request?: SecondParameter<typeof customInstance>;
 }) => {
-  const { mutation: mutationOptions, axios: axiosOptions } = options || {};
+  const { mutation: mutationOptions, request: requestOptions } = options || {};
 
   const mutationFn: MutationFunction<
-    AsyncReturnType<typeof appApiProductPatch>,
+    AsyncReturnType<typeof patchProduct>,
     { unitId: string; productId: string; data: ProductPatchBodyBody }
   > = (props) => {
     const { unitId, productId, data } = props || {};
 
-    return appApiProductPatch(unitId, productId, data, axiosOptions);
+    return patchProduct(unitId, productId, data, requestOptions);
   };
 
   return useMutation<
-    AsyncReturnType<typeof appApiProductPatch>,
+    AsyncReturnType<typeof patchProduct>,
     TError,
     { unitId: string; productId: string; data: ProductPatchBodyBody },
     TContext