@squonk/account-server-client 0.1.26 → 0.1.28

package/src/product/product.ts

@@ -8,124 +8,415 @@ A service that provides access to the Account Server, which gives *registered* u
 
  * OpenAPI spec version: 0.1
  */
-import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+import {
+  useQuery,
+  useMutation,
+  UseQueryOptions,
+  UseMutationOptions,
+  QueryFunction,
+  MutationFunction,
+  UseQueryResult,
+  QueryKey,
+} from "react-query";
 import type {
   ProductsGetTypesResponse,
+  AsError,
   ProductsGetResponse,
   UnitProductPostResponse,
   UnitProductPostBodyBody,
   ProductUnitGetResponse,
   ProductPatchBodyBody,
 } from "../account-server-api.schemas";
+import { customInstance, ErrorType } from ".././custom-instance";
 
-export const getProduct = () => {
-  /**
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (
+  ...args: any
+) => Promise<infer R>
+  ? 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
  */
-  const appApiProductGetTypes = <
-    TData = AxiosResponse<ProductsGetTypesResponse>
-  >(
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.get(`/product-type`, options);
+export const getProductTypes = (
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ProductsGetTypesResponse>(
+    { url: `/product-type`, method: "get" },
+    options
+  );
+};
+
+export const getGetProductTypesQueryKey = () => [`/product-type`];
+
+export type GetProductTypesQueryResult = NonNullable<
+  AsyncReturnType<typeof getProductTypes>
+>;
+export type GetProductTypesQueryError = ErrorType<AsError | void>;
+
+export const useGetProductTypes = <
+  TData = AsyncReturnType<typeof getProductTypes>,
+  TError = ErrorType<AsError | void>
+>(options?: {
+  query?: UseQueryOptions<
+    AsyncReturnType<typeof getProductTypes>,
+    TError,
+    TData
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
+  const { query: queryOptions, request: requestOptions } = options || {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetProductTypesQueryKey();
+
+  const queryFn: QueryFunction<AsyncReturnType<typeof getProductTypes>> = () =>
+    getProductTypes(requestOptions);
+
+  const query = useQuery<
+    AsyncReturnType<typeof getProductTypes>,
+    TError,
+    TData
+  >(queryKey, queryFn, queryOptions);
+
+  return {
+    queryKey,
+    ...query,
   };
-  /**
+};
+
+/**
  * Gets products you have access to, across all Units and Organisations
 
  * @summary Gets all Products
  */
-  const appApiProductGet = <TData = AxiosResponse<ProductsGetResponse>>(
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.get(`/product`, options);
+export const getProducts = (
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ProductsGetResponse>(
+    { url: `/product`, method: "get" },
+    options
+  );
+};
+
+export const getGetProductsQueryKey = () => [`/product`];
+
+export type GetProductsQueryResult = NonNullable<
+  AsyncReturnType<typeof getProducts>
+>;
+export type GetProductsQueryError = ErrorType<AsError | void>;
+
+export const useGetProducts = <
+  TData = AsyncReturnType<typeof getProducts>,
+  TError = ErrorType<AsError | void>
+>(options?: {
+  query?: UseQueryOptions<AsyncReturnType<typeof getProducts>, TError, TData>;
+  request?: SecondParameter<typeof customInstance>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
+  const { query: queryOptions, request: requestOptions } = options || {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetProductsQueryKey();
+
+  const queryFn: QueryFunction<AsyncReturnType<typeof getProducts>> = () =>
+    getProducts(requestOptions);
+
+  const query = useQuery<AsyncReturnType<typeof getProducts>, TError, TData>(
+    queryKey,
+    queryFn,
+    queryOptions
+  );
+
+  return {
+    queryKey,
+    ...query,
   };
-  /**
-   * @summary Creates a Product for an Organisational Unit
-   */
-  const appApiProductPost = <TData = AxiosResponse<UnitProductPostResponse>>(
-    unitId: string,
-    unitProductPostBodyBody: UnitProductPostBodyBody,
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.post(
-      `/product/unit/${unitId}`,
-      unitProductPostBodyBody,
-      options
-    );
+};
+
+/**
+ * @summary Creates a Product for an Organisational Unit
+ */
+export const createUnitProduct = (
+  unitId: string,
+  unitProductPostBodyBody: UnitProductPostBodyBody,
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<UnitProductPostResponse>(
+    {
+      url: `/product/unit/${unitId}`,
+      method: "post",
+      headers: { "Content-Type": "application/json" },
+      data: unitProductPostBodyBody,
+    },
+    options
+  );
+};
+
+export type CreateUnitProductMutationResult = NonNullable<
+  AsyncReturnType<typeof createUnitProduct>
+>;
+export type CreateUnitProductMutationBody = UnitProductPostBodyBody;
+export type CreateUnitProductMutationError = ErrorType<AsError | void>;
+
+export const useCreateUnitProduct = <
+  TError = ErrorType<AsError | void>,
+  TContext = unknown
+>(options?: {
+  mutation?: UseMutationOptions<
+    AsyncReturnType<typeof createUnitProduct>,
+    TError,
+    { unitId: string; data: UnitProductPostBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}) => {
+  const { mutation: mutationOptions, request: requestOptions } = options || {};
+
+  const mutationFn: MutationFunction<
+    AsyncReturnType<typeof createUnitProduct>,
+    { unitId: string; data: UnitProductPostBodyBody }
+  > = (props) => {
+    const { unitId, data } = props || {};
+
+    return createUnitProduct(unitId, data, requestOptions);
   };
-  /**
+
+  return useMutation<
+    AsyncReturnType<typeof createUnitProduct>,
+    TError,
+    { unitId: string; data: UnitProductPostBodyBody },
+    TContext
+  >(mutationFn, mutationOptions);
+};
+/**
  * Gets products you have access to based on an Organisational Unit
 
  * @summary Gets Products for an Organisational Unit
  */
-  const appApiProductGetForUnit = <TData = AxiosResponse<ProductsGetResponse>>(
-    unitId: string,
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.get(`/product/unit/${unitId}`, options);
+export const getProductsForUnit = (
+  unitId: string,
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ProductsGetResponse>(
+    { url: `/product/unit/${unitId}`, method: "get" },
+    options
+  );
+};
+
+export const getGetProductsForUnitQueryKey = (unitId: string) => [
+  `/product/unit/${unitId}`,
+];
+
+export type GetProductsForUnitQueryResult = NonNullable<
+  AsyncReturnType<typeof getProductsForUnit>
+>;
+export type GetProductsForUnitQueryError = ErrorType<void | AsError>;
+
+export const useGetProductsForUnit = <
+  TData = AsyncReturnType<typeof getProductsForUnit>,
+  TError = ErrorType<void | AsError>
+>(
+  unitId: string,
+  options?: {
+    query?: UseQueryOptions<
+      AsyncReturnType<typeof getProductsForUnit>,
+      TError,
+      TData
+    >;
+    request?: SecondParameter<typeof customInstance>;
+  }
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
+  const { query: queryOptions, request: requestOptions } = options || {};
+
+  const queryKey =
+    queryOptions?.queryKey ?? getGetProductsForUnitQueryKey(unitId);
+
+  const queryFn: QueryFunction<
+    AsyncReturnType<typeof getProductsForUnit>
+  > = () => getProductsForUnit(unitId, requestOptions);
+
+  const query = useQuery<
+    AsyncReturnType<typeof getProductsForUnit>,
+    TError,
+    TData
+  >(queryKey, queryFn, { enabled: !!unitId, ...queryOptions });
+
+  return {
+    queryKey,
+    ...query,
   };
-  /**
+};
+
+/**
  * Gets a Unit's Product
 
  * @summary Gets a Unit's Product
  */
-  const appApiProductGetUnitProduct = <
-    TData = AxiosResponse<ProductUnitGetResponse>
-  >(
-    unitId: string,
-    productId: string,
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.get(`/product/unit/${unitId}/product/${productId}`, options);
+export const getProduct = (
+  unitId: string,
+  productId: string,
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ProductUnitGetResponse>(
+    { url: `/product/unit/${unitId}/product/${productId}`, method: "get" },
+    options
+  );
+};
+
+export const getGetProductQueryKey = (unitId: string, productId: string) => [
+  `/product/unit/${unitId}/product/${productId}`,
+];
+
+export type GetProductQueryResult = NonNullable<
+  AsyncReturnType<typeof getProduct>
+>;
+export type GetProductQueryError = ErrorType<AsError | void>;
+
+export const useGetProduct = <
+  TData = AsyncReturnType<typeof getProduct>,
+  TError = ErrorType<AsError | void>
+>(
+  unitId: string,
+  productId: string,
+  options?: {
+    query?: UseQueryOptions<AsyncReturnType<typeof getProduct>, TError, TData>;
+    request?: SecondParameter<typeof customInstance>;
+  }
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
+  const { query: queryOptions, request: requestOptions } = options || {};
+
+  const queryKey =
+    queryOptions?.queryKey ?? getGetProductQueryKey(unitId, productId);
+
+  const queryFn: QueryFunction<AsyncReturnType<typeof getProduct>> = () =>
+    getProduct(unitId, productId, requestOptions);
+
+  const query = useQuery<AsyncReturnType<typeof getProduct>, TError, TData>(
+    queryKey,
+    queryFn,
+    { enabled: !!(unitId && productId), ...queryOptions }
+  );
+
+  return {
+    queryKey,
+    ...query,
   };
-  /**
-   * @summary Deletes an existing Product
-   */
-  const appApiProductDelete = <TData = AxiosResponse<void>>(
-    unitId: string,
-    productId: string,
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.delete(
-      `/product/unit/${unitId}/product/${productId}`,
-      options
-    );
+};
+
+/**
+ * @summary Deletes an existing Product
+ */
+export const deleteProduct = (
+  unitId: string,
+  productId: string,
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<void>(
+    { url: `/product/unit/${unitId}/product/${productId}`, method: "delete" },
+    options
+  );
+};
+
+export type DeleteProductMutationResult = NonNullable<
+  AsyncReturnType<typeof deleteProduct>
+>;
+
+export type DeleteProductMutationError = ErrorType<AsError>;
+
+export const useDeleteProduct = <
+  TError = ErrorType<AsError>,
+  TContext = unknown
+>(options?: {
+  mutation?: UseMutationOptions<
+    AsyncReturnType<typeof deleteProduct>,
+    TError,
+    { unitId: string; productId: string },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}) => {
+  const { mutation: mutationOptions, request: requestOptions } = options || {};
+
+  const mutationFn: MutationFunction<
+    AsyncReturnType<typeof deleteProduct>,
+    { unitId: string; productId: string }
+  > = (props) => {
+    const { unitId, productId } = props || {};
+
+    return deleteProduct(unitId, productId, requestOptions);
   };
-  /**
+
+  return useMutation<
+    AsyncReturnType<typeof deleteProduct>,
+    TError,
+    { unitId: string; productId: string },
+    TContext
+  >(mutationFn, mutationOptions);
+};
+/**
  * Used to update some adjustable parameters of a Product, i.e. to extend the Allowance or Limit. At the moment Data Manager products can be patched by changing the `name`, it's coin `allowance` or `limit`
 
  * @summary Adjust an existing Product
  */
-  const appApiProductPatch = <TData = AxiosResponse<void>>(
-    unitId: string,
-    productId: string,
-    productPatchBodyBody: ProductPatchBodyBody,
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.patch(
-      `/product/unit/${unitId}/product/${productId}`,
-      productPatchBodyBody,
-      options
-    );
-  };
-  return {
-    appApiProductGetTypes,
-    appApiProductGet,
-    appApiProductPost,
-    appApiProductGetForUnit,
-    appApiProductGetUnitProduct,
-    appApiProductDelete,
-    appApiProductPatch,
+export const patchProduct = (
+  unitId: string,
+  productId: string,
+  productPatchBodyBody: 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 PatchProductMutationResult = NonNullable<
+  AsyncReturnType<typeof patchProduct>
+>;
+export type PatchProductMutationBody = ProductPatchBodyBody;
+export type PatchProductMutationError = ErrorType<AsError>;
+
+export const usePatchProduct = <
+  TError = ErrorType<AsError>,
+  TContext = unknown
+>(options?: {
+  mutation?: UseMutationOptions<
+    AsyncReturnType<typeof patchProduct>,
+    TError,
+    { unitId: string; productId: string; data: ProductPatchBodyBody },
+    TContext
+  >;
+  request?: SecondParameter<typeof customInstance>;
+}) => {
+  const { mutation: mutationOptions, request: requestOptions } = options || {};
+
+  const mutationFn: MutationFunction<
+    AsyncReturnType<typeof patchProduct>,
+    { unitId: string; productId: string; data: ProductPatchBodyBody }
+  > = (props) => {
+    const { unitId, productId, data } = props || {};
+
+    return patchProduct(unitId, productId, data, requestOptions);
   };
+
+  return useMutation<
+    AsyncReturnType<typeof patchProduct>,
+    TError,
+    { unitId: string; productId: string; data: ProductPatchBodyBody },
+    TContext
+  >(mutationFn, mutationOptions);
 };
-export type AppApiProductGetTypesResult =
-  AxiosResponse<ProductsGetTypesResponse>;
-export type AppApiProductGetResult = AxiosResponse<ProductsGetResponse>;
-export type AppApiProductPostResult = AxiosResponse<UnitProductPostResponse>;
-export type AppApiProductGetForUnitResult = AxiosResponse<ProductsGetResponse>;
-export type AppApiProductGetUnitProductResult =
-  AxiosResponse<ProductUnitGetResponse>;
-export type AppApiProductDeleteResult = AxiosResponse<void>;
-export type AppApiProductPatchResult = AxiosResponse<void>;

package/src/service/service.ts

@@ -8,35 +8,129 @@ A service that provides access to the Account Server, which gives *registered* u
 
  * OpenAPI spec version: 0.1
  */
-import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+import {
+  useQuery,
+  UseQueryOptions,
+  QueryFunction,
+  UseQueryResult,
+  QueryKey,
+} from "react-query";
 import type {
   ServicesGetResponse,
+  AsError,
   ServiceGetResponse,
 } from "../account-server-api.schemas";
+import { customInstance, ErrorType } from ".././custom-instance";
 
-export const getService = () => {
-  /**
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (
+  ...args: any
+) => Promise<infer R>
+  ? 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 services known to the Account Server
 
  * @summary Gets all Services
  */
-  const appApiServiceGet = <TData = AxiosResponse<ServicesGetResponse>>(
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.get(`/service`, options);
+export const getServices = (
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ServicesGetResponse>(
+    { url: `/service`, method: "get" },
+    options
+  );
+};
+
+export const getGetServicesQueryKey = () => [`/service`];
+
+export type GetServicesQueryResult = NonNullable<
+  AsyncReturnType<typeof getServices>
+>;
+export type GetServicesQueryError = ErrorType<AsError | void>;
+
+export const useGetServices = <
+  TData = AsyncReturnType<typeof getServices>,
+  TError = ErrorType<AsError | void>
+>(options?: {
+  query?: UseQueryOptions<AsyncReturnType<typeof getServices>, TError, TData>;
+  request?: SecondParameter<typeof customInstance>;
+}): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
+  const { query: queryOptions, request: requestOptions } = options || {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetServicesQueryKey();
+
+  const queryFn: QueryFunction<AsyncReturnType<typeof getServices>> = () =>
+    getServices(requestOptions);
+
+  const query = useQuery<AsyncReturnType<typeof getServices>, TError, TData>(
+    queryKey,
+    queryFn,
+    queryOptions
+  );
+
+  return {
+    queryKey,
+    ...query,
   };
-  /**
+};
+
+/**
  * Gets a known service
 
  * @summary Gets a specific Service
  */
-  const appApiServiceGetId = <TData = AxiosResponse<ServiceGetResponse>>(
-    svcId: number,
-    options?: AxiosRequestConfig
-  ): Promise<TData> => {
-    return axios.get(`/service/${svcId}`, options);
+export const getService = (
+  svcId: number,
+  options?: SecondParameter<typeof customInstance>
+) => {
+  return customInstance<ServiceGetResponse>(
+    { url: `/service/${svcId}`, method: "get" },
+    options
+  );
+};
+
+export const getGetServiceQueryKey = (svcId: number) => [`/service/${svcId}`];
+
+export type GetServiceQueryResult = NonNullable<
+  AsyncReturnType<typeof getService>
+>;
+export type GetServiceQueryError = ErrorType<AsError | void>;
+
+export const useGetService = <
+  TData = AsyncReturnType<typeof getService>,
+  TError = ErrorType<AsError | void>
+>(
+  svcId: number,
+  options?: {
+    query?: UseQueryOptions<AsyncReturnType<typeof getService>, TError, TData>;
+    request?: SecondParameter<typeof customInstance>;
+  }
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } => {
+  const { query: queryOptions, request: requestOptions } = options || {};
+
+  const queryKey = queryOptions?.queryKey ?? getGetServiceQueryKey(svcId);
+
+  const queryFn: QueryFunction<AsyncReturnType<typeof getService>> = () =>
+    getService(svcId, requestOptions);
+
+  const query = useQuery<AsyncReturnType<typeof getService>, TError, TData>(
+    queryKey,
+    queryFn,
+    { enabled: !!svcId, ...queryOptions }
+  );
+
+  return {
+    queryKey,
+    ...query,
   };
-  return { appApiServiceGet, appApiServiceGetId };
 };
-export type AppApiServiceGetResult = AxiosResponse<ServicesGetResponse>;
-export type AppApiServiceGetIdResult = AxiosResponse<ServiceGetResponse>;