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

package/dist/composables/mutation/mutation.composable.d.ts

@@ -0,0 +1,48 @@
+import { ComputedRef, UnwrapRef } from 'vue';
+import { QueryKeys } from '../../types/queryKeys.type';
+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]>;
+        };
+    };
+}
+export 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>;
+}
+export declare function useMutation<TReqData = void, TResData = void, TParams = void>(options: UseMutationOptions<TParams, TReqData, TResData>): UseMutationReturnType<TReqData, TResData, TParams>;
+export {};

package/dist/composables/mutation/mutation.composable.spec.d.ts

@@ -0,0 +1,3 @@
+import { QueryClient } from '@tanstack/vue-query';
+import { App } from 'vue';
+export declare function withSetup<T>(composable: (queryClient: QueryClient) => T): [T | null, App];

package/dist/composables/query/keysetInfiniteQuery.composable.d.ts

@@ -0,0 +1,50 @@
+import { MaybeRef } from 'vue';
+import { KeysetPaginationParams, KeysetPaginationResult } from '../../types/pagination.type';
+import { QueryKeys } from '../../types/queryKeys.type';
+type NonOptionalKeys<T> = {
+    [K in keyof T]-?: T[K];
+};
+export 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<QueryKeys[TQueryKey]>]: MaybeRef<QueryKeys[TQueryKey][TQueryKeyParam]>;
+        };
+    };
+}
+export declare function useKeysetInfiniteQuery<TData>(options: KeysetInfiniteQueryOptions<TData>): {
+    hasNextPage: import('vue').ComputedRef<boolean>;
+    isError: import('vue').ComputedRef<boolean>;
+    isFetching: import('vue').ComputedRef<boolean>;
+    isFetchingNextPage: import('vue').ComputedRef<boolean>;
+    isLoading: import('vue').ComputedRef<boolean>;
+    isSuccess: import('vue').ComputedRef<boolean>;
+    fetchNextPage: () => Promise<import('@tanstack/vue-query').InfiniteQueryObserverResult<import('@tanstack/vue-query').InfiniteData<KeysetPaginationResult<TData>, unknown>, Error>> | undefined;
+    refetch: () => Promise<void>;
+    result: import('vue').ComputedRef<KeysetPaginationResult<TData>>;
+};
+export {};

package/dist/composables/query/offsetInfiniteQuery.composable.d.ts

@@ -0,0 +1,50 @@
+import { MaybeRef } from 'vue';
+import { OffsetPaginationParams, OffsetPaginationResult } from '../../types/pagination.type';
+import { QueryKeys } from '../../types/queryKeys.type';
+type NonOptionalKeys<T> = {
+    [K in keyof T]-?: T[K];
+};
+export 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<QueryKeys[TQueryKey]>]: MaybeRef<QueryKeys[TQueryKey][TQueryKeyParam]>;
+        };
+    };
+}
+export declare function useOffsetInfiniteQuery<TData>(options: OffsetInfiniteQueryOptions<TData>): {
+    hasNextPage: import('vue').ComputedRef<boolean>;
+    isError: import('vue').ComputedRef<boolean>;
+    isFetching: import('vue').ComputedRef<boolean>;
+    isFetchingNextPage: import('vue').ComputedRef<boolean>;
+    isLoading: import('vue').ComputedRef<boolean>;
+    isSuccess: import('vue').ComputedRef<boolean>;
+    fetchNextPage: () => Promise<import('@tanstack/vue-query').InfiniteQueryObserverResult<import('@tanstack/vue-query').InfiniteData<OffsetPaginationResult<TData>, unknown>, Error>> | undefined;
+    refetch: () => Promise<void>;
+    result: import('vue').ComputedRef<OffsetPaginationResult<TData>>;
+};
+export {};

package/dist/composables/query/prefetchQuery.composable.d.ts

@@ -0,0 +1,4 @@
+import { UseQueryOptions } from './query.composable';
+export declare function usePrefetchQuery<TResData>(query: UseQueryOptions<TResData>): {
+    execute: () => Promise<void>;
+};

package/dist/composables/query/query.composable.d.ts

@@ -0,0 +1,74 @@
+import { ComputedRef, MaybeRef } from 'vue';
+import { ApiResult } from '../../types/apiError.type';
+import { QueryKeys } from '../../types/queryKeys.type';
+type NonOptionalKeys<T> = {
+    [K in keyof T]-?: T[K];
+};
+export 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]>;
+        };
+    };
+}
+export 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>;
+}
+export declare function useQuery<TResData>(options: UseQueryOptions<TResData>): UseQueryReturnType<TResData>;
+export {};

package/dist/config/config.d.ts

@@ -0,0 +1,9 @@
+export declare const QUERY_CONFIG: {
+    prefetchStaleTime: number;
+    limit: number;
+};
+export interface QueryConfig {
+    prefetchStaleTime: number;
+    limit: number;
+}
+export declare function setQueryConfig(config: Partial<QueryConfig>): void;

package/dist/index.d.ts

@@ -1,307 +1,11 @@
-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 };
+export * from './composables/mutation/mutation.composable';
+export * from './composables/query/keysetInfiniteQuery.composable';
+export * from './composables/query/offsetInfiniteQuery.composable';
+export * from './composables/query/prefetchQuery.composable';
+export * from './composables/query/query.composable';
+export { type QueryConfig, setQueryConfig, } from './config/config';
+export * from './types/apiError.type';
+export * from './types/pagination.type';
+export * from './types/query.type';
+export * from './types/queryKeys.type';
+export * from './types/sort.type';