@wisemen/vue-core-api-utils 0.0.1-beta.0

package/README.md

@@ -0,0 +1 @@
+# Tanstack query wrapper

package/dist/index.d.ts

@@ -0,0 +1,307 @@
+import * as _tanstack_vue_query0 from "@tanstack/vue-query";
+import { Result } from "neverthrow";
+import * as vue0 from "vue";
+import { ComputedRef, MaybeRef, Ref, UnwrapRef } from "vue";
+
+//#region src/types/queryKeys.type.d.ts
+interface QueryKeys {}
+//#endregion
+//#region src/composables/mutation/mutation.composable.d.ts
+type RequestParams<TReqData, TParams> = TReqData extends void ? TParams extends void ? void : {
+  params: TParams;
+} : TParams extends void ? {
+  body: TReqData;
+} : {
+  body: TReqData;
+  params: TParams;
+};
+interface UseMutationOptions<TParams, TReqData, TResData> {
+  /**
+   * Whether to enable debug mode
+   */
+  isDebug?: boolean;
+  /**
+   * Function that will be called to perform the mutation
+   * @param options - Parameters and body for the mutation
+   * @returns Promise with the response data
+   */
+  queryFn: (options: RequestParams<TReqData, TParams>) => Promise<TResData>;
+  /**
+   * Array of query keys which should be invalidated after mutation is successful
+   */
+  queryKeysToInvalidate: { [TQueryKey in keyof QueryKeys]?: { [TQueryKeyParam in keyof QueryKeys[TQueryKey]]: (params: TParams, data: TResData) => UnwrapRef<QueryKeys[TQueryKey][TQueryKeyParam]> } };
+}
+interface UseMutationReturnType<TReqData, TResData, TParams = void> {
+  /**
+   * Whether mutation is loading
+   */
+  isLoading: ComputedRef<boolean>;
+  /**
+   * Response data from the mutation
+   */
+  data: ComputedRef<TResData extends unknown[] ? TResData[] : TResData | null>;
+  /**
+   * Function to execute the mutation
+   * @param data - Parameters and body for the mutation
+   * @returns Promise with the response data
+   */
+  execute: (data: RequestParams<TReqData, TParams>) => Promise<TResData>;
+}
+declare function useMutation<TReqData = void, TResData = void, TParams = void>(options: UseMutationOptions<TParams, TReqData, TResData>): UseMutationReturnType<TReqData, TResData, TParams>;
+//#endregion
+//#region src/types/apiError.type.d.ts
+interface ApiErrorCodes {}
+type ApiErrorCode = ApiErrorCodes[keyof ApiErrorCodes];
+interface ApiKnownErrorObject {
+  code: ApiErrorCode;
+  detail: string;
+  source?: {
+    pointer: string;
+  };
+  status: string;
+}
+interface ApiUnknownErrorObject {
+  code: string;
+  detail: string;
+  source?: {
+    pointer: string;
+  };
+  status: string;
+}
+type ApiErrorObject = ApiKnownErrorObject | ApiUnknownErrorObject;
+interface ApiExpectedError {
+  errors: ApiErrorObject[];
+}
+type ApiUnexpectedError = Error;
+type ApiError = ApiExpectedError | ApiUnexpectedError;
+type ApiResult<T> = Result<T, ApiError>;
+//#endregion
+//#region src/types/sort.type.d.ts
+type SortDirection = 'asc' | 'desc';
+interface Sort<TKey extends string = string> {
+  direction: SortDirection;
+  key: TKey;
+}
+//#endregion
+//#region src/types/query.type.d.ts
+interface QueryParams {
+  filters?: Record<string, any>;
+  search?: string;
+  sort?: Sort[];
+}
+interface WithSearchQuery {
+  search: string;
+}
+interface WithSortQuery<TKeys extends string> {
+  sort: Sort<TKeys>[];
+}
+interface WithFilterQuery<TFilters extends Record<string, any>> {
+  filters: TFilters;
+}
+interface InfiniteQueryOptions<TParams> {
+  params: { [K in keyof TParams]: Ref<TParams[K]> };
+}
+//#endregion
+//#region src/types/pagination.type.d.ts
+interface OffsetPaginationParams {
+  limit: number;
+  offset: number;
+}
+type OffsetPagination<T extends QueryParams = Record<string, never>> = {
+  pagination: OffsetPaginationParams;
+} & T;
+interface KeysetPaginationParams {
+  key?: any;
+  limit: number;
+}
+type KeysetPagination<T extends QueryParams> = {
+  pagination: KeysetPaginationParams;
+} & T;
+interface OffsetPaginationResponse<TData> {
+  data: TData[];
+  meta: {
+    limit: number;
+    offset: number;
+    total: number;
+  };
+}
+interface KeysetPaginationResponse<TData> {
+  data: TData[];
+  meta: {
+    next: unknown;
+  };
+}
+type OffsetPaginationResult<TData> = ApiResult<OffsetPaginationResponse<TData>>;
+type KeysetPaginationResult<TData> = ApiResult<KeysetPaginationResponse<TData>>;
+interface PaginatedDataDto<TSchema> {
+  items: TSchema[];
+  meta: {
+    limit: number;
+    offset: number;
+    total: number;
+  };
+}
+//#endregion
+//#region src/composables/query/keysetInfiniteQuery.composable.d.ts
+type NonOptionalKeys$2<T> = { [K in keyof T]-?: T[K] };
+interface KeysetInfiniteQueryOptions<TData> {
+  /**
+   * The time in milliseconds after which the query will be considered stale
+   * After this time, the query will be refetched automatically in the background when it is rendered or accessed
+   * @default 0
+   */
+  staleTime?: number;
+  /**
+   * Whether the query is enabled
+   * If false, the query will not be executed
+   * @default true
+   */
+  isEnabled?: MaybeRef<boolean>;
+  /**
+   * Maximum number of items to fetch per page, default can be set in config
+   * @default 20
+   */
+  limit?: number;
+  /**
+   * Function that will be called when query is executed
+   * @returns Promise with response data
+   */
+  queryFn: (paginationParams: KeysetPaginationParams) => Promise<KeysetPaginationResult<TData>>;
+  /**
+   * Query key associated with the query
+   */
+  queryKey: { [TQueryKey in keyof QueryKeys]?: { [TQueryKeyParam in keyof NonOptionalKeys$2<QueryKeys[TQueryKey]>]: MaybeRef<QueryKeys[TQueryKey][TQueryKeyParam]> } };
+}
+declare function useKeysetInfiniteQuery<TData>(options: KeysetInfiniteQueryOptions<TData>): {
+  hasNextPage: vue0.ComputedRef<boolean>;
+  isError: vue0.ComputedRef<boolean>;
+  isFetching: vue0.ComputedRef<boolean>;
+  isFetchingNextPage: vue0.ComputedRef<boolean>;
+  isLoading: vue0.ComputedRef<boolean>;
+  isSuccess: vue0.ComputedRef<boolean>;
+  fetchNextPage: () => Promise<_tanstack_vue_query0.InfiniteQueryObserverResult<_tanstack_vue_query0.InfiniteData<KeysetPaginationResult<TData>, unknown>, Error>> | undefined;
+  refetch: () => Promise<void>;
+  result: vue0.ComputedRef<KeysetPaginationResult<TData>>;
+};
+//#endregion
+//#region src/composables/query/offsetInfiniteQuery.composable.d.ts
+type NonOptionalKeys$1<T> = { [K in keyof T]-?: T[K] };
+interface OffsetInfiniteQueryOptions<TData> {
+  /**
+   * The time in milliseconds after which the query will be considered stale
+   * After this time, the query will be refetched automatically in the background when it is rendered or accessed
+   * @default 0
+   */
+  staleTime?: number;
+  /**
+   * Whether the query is enabled
+   * If false, the query will not be executed
+   * @default true
+   */
+  isEnabled?: MaybeRef<boolean>;
+  /**
+   * Maximum number of items to fetch per page, default can be set in config
+   * @default 20
+   */
+  limit?: number;
+  /**
+   * Function that will be called when query is executed
+   * @returns Promise with response data
+   */
+  queryFn: (paginationParams: OffsetPaginationParams) => Promise<OffsetPaginationResult<TData>>;
+  /**
+   * Query key associated with the query
+   */
+  queryKey: { [TQueryKey in keyof QueryKeys]?: { [TQueryKeyParam in keyof NonOptionalKeys$1<QueryKeys[TQueryKey]>]: MaybeRef<QueryKeys[TQueryKey][TQueryKeyParam]> } };
+}
+declare function useOffsetInfiniteQuery<TData>(options: OffsetInfiniteQueryOptions<TData>): {
+  hasNextPage: vue0.ComputedRef<boolean>;
+  isError: vue0.ComputedRef<boolean>;
+  isFetching: vue0.ComputedRef<boolean>;
+  isFetchingNextPage: vue0.ComputedRef<boolean>;
+  isLoading: vue0.ComputedRef<boolean>;
+  isSuccess: vue0.ComputedRef<boolean>;
+  fetchNextPage: () => Promise<_tanstack_vue_query0.InfiniteQueryObserverResult<_tanstack_vue_query0.InfiniteData<OffsetPaginationResult<TData>, unknown>, Error>> | undefined;
+  refetch: () => Promise<void>;
+  result: vue0.ComputedRef<OffsetPaginationResult<TData>>;
+};
+//#endregion
+//#region src/composables/query/query.composable.d.ts
+type NonOptionalKeys<T> = { [K in keyof T]-?: T[K] };
+interface UseQueryOptions<TResData> {
+  /**
+   * The time in milliseconds after which the query will be considered stale
+   * After this time, the query will be refetched automatically in the background when it is rendered or accessed
+   * @default 0
+   */
+  staleTime?: number;
+  /**
+   * Whether to enable debug mode
+   * When enabled, the query key and parameters will be logged to the console
+   * @default false
+   */
+  isDebug?: boolean;
+  /**
+   * Whether the query is enabled
+   * If false, the query will not be executed
+   * @default true
+   */
+  isEnabled?: MaybeRef<boolean>;
+  /**
+   * Function that will be called when query is executed
+   * @returns Promise with response data
+   */
+  queryFn: () => Promise<ApiResult<TResData>>;
+  /**
+   * Query key associated with the query
+   */
+  queryKey: { [TQueryKey in keyof QueryKeys]?: { [TQueryKeyParam in keyof NonOptionalKeys<QueryKeys[TQueryKey]>]: MaybeRef<QueryKeys[TQueryKey][TQueryKeyParam]> } };
+}
+interface UseQueryReturnType<TResData> {
+  /**
+   * Response data
+   */
+  /**
+   * Whether query has errored at least once
+   * @deprecated - use `result.isErr()` instead
+   */
+  isError: ComputedRef<boolean>;
+  /**
+   * Whether query is currently loading
+   */
+  isFetching: ComputedRef<boolean>;
+  /**
+   * Whether query is initially loading
+   */
+  isLoading: ComputedRef<boolean>;
+  /**
+   * Whether query has been executed successfully
+   * @deprecated - use `result.isOk()` instead
+   */
+  isSuccess: ComputedRef<boolean>;
+  /**
+   * Refetch the query
+   */
+  refetch: () => Promise<void>;
+  /**
+   * Computed result of the query
+   * It will return an instance of Result<TResData, ApiError>
+   * where TResData is the response data and ApiError is the error
+   */
+  result: ComputedRef<ApiResult<TResData> | null>;
+}
+declare function useQuery<TResData>(options: UseQueryOptions<TResData>): UseQueryReturnType<TResData>;
+//#endregion
+//#region src/composables/query/prefetchQuery.composable.d.ts
+declare function usePrefetchQuery<TResData>(query: UseQueryOptions<TResData>): {
+  execute: () => Promise<void>;
+};
+//#endregion
+//#region src/config/config.d.ts
+interface QueryConfig {
+  prefetchStaleTime: number;
+  limit: number;
+}
+declare function setQueryConfig(config: Partial<QueryConfig>): void;
+//#endregion
+export { ApiError, ApiErrorCode, ApiErrorCodes, ApiErrorObject, ApiExpectedError, ApiKnownErrorObject, ApiResult, ApiUnexpectedError, ApiUnknownErrorObject, InfiniteQueryOptions, KeysetInfiniteQueryOptions, KeysetPagination, KeysetPaginationParams, KeysetPaginationResponse, KeysetPaginationResult, OffsetInfiniteQueryOptions, OffsetPagination, OffsetPaginationParams, OffsetPaginationResponse, OffsetPaginationResult, PaginatedDataDto, type QueryConfig, QueryKeys, QueryParams, Sort, SortDirection, UseMutationReturnType, UseQueryOptions, UseQueryReturnType, WithFilterQuery, WithSearchQuery, WithSortQuery, setQueryConfig, useKeysetInfiniteQuery, useMutation, useOffsetInfiniteQuery, usePrefetchQuery, useQuery };