@codeleap/query 4.3.0

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './QueryManager'
+export * from './queryClient'
+export * from './types'
+
+import * as ReactQuery from '@tanstack/react-query'
+
+export {
+  ReactQuery
+}

package/src/queryClient.ts

@@ -0,0 +1,260 @@
+import * as ReactQuery from '@tanstack/react-query'
+import { waitFor } from '@codeleap/utils'
+import { QueryManagerOptions, QueryManagerItem } from './types'
+import { QueryManager } from './QueryManager'
+
+export type QueryKeyBuilder<Args extends any[] = any[]> = (...args:Args) => ReactQuery.QueryKey
+
+type PollingResult<T> = {
+  stop: boolean
+  data: T
+}
+
+type PollingCallback<T, R> = (query: ReactQuery.Query<T>, count: number, prev?: R) => Promise<PollingResult<R>>
+
+type PollQueryOptions<T, R> = {
+  interval: number
+  callback: PollingCallback<T, R>
+  leading?: boolean
+  initialData?: R
+}
+
+interface EnhancedQuery<T> extends ReactQuery.Query<T> {
+  waitForRefresh(): Promise<ReactQuery.Query<T>>
+  listen(callback: (e: ReactQuery.QueryCacheNotifyEvent) => void): () => void
+  refresh(): Promise<T>
+  poll<R>(
+    options: PollQueryOptions<T, R>
+  ): Promise<R>
+  getData(): T
+  ensureData(options?: Partial<ReactQuery.EnsureQueryDataOptions<T, Error, T, ReactQuery.QueryKey, never>>): Promise<T>
+  key: ReactQuery.QueryKey
+}
+
+type DynamicEnhancedQuery<T, BuilderArgs extends any[]> = {
+  [P in keyof EnhancedQuery<T>]: (...args: BuilderArgs) => EnhancedQuery<T>[P]
+}
+
+export class CodeleapQueryClient {
+  constructor(public client: ReactQuery.QueryClient) {
+  }
+
+  listenToQuery(key: ReactQuery.QueryKey, callback: (e: ReactQuery.QueryCacheNotifyEvent) => void) {
+    const cache = this.client.getQueryCache()
+
+    const query = cache.find({ exact: true, queryKey: key })
+
+    if (!query) {
+      return
+    }
+
+    const removeListener = cache.subscribe((e) => {
+      const matches = ReactQuery.matchQuery({ exact: true, queryKey: key }, e.query)
+
+      if (matches) {
+        callback(e)
+
+      }
+    })
+
+    return removeListener
+  }
+
+  async pollQuery<T, R>(
+    key: ReactQuery.QueryKey,
+    options: PollQueryOptions<T, R>,
+  ) {
+    const { interval, callback, initialData, leading = false } = options
+    const cache = this.client.getQueryCache()
+
+    const initialQuery = cache.find({ exact: true, queryKey: key })
+
+    if (!initialQuery) {
+      return Promise.reject(new Error('Query not found'))
+    }
+
+    let count = 0
+    let result: PollingResult<R> = {
+      stop: false,
+      data: initialData,
+    }
+
+    while (!result?.stop) {
+      const shouldWait = count > 0 || leading
+
+      if (shouldWait) {
+        await waitFor(interval)
+      }
+
+      this.client.refetchQueries({
+        exact: true,
+        queryKey: key,
+      })
+
+      const newQuery = await this.waitForRefresh<T>(key)
+
+      const newResult = await callback(newQuery, count, result?.data)
+
+      count += 1
+      result = newResult
+    }
+
+    return result?.data
+
+  }
+
+  queryProxy<T>(key: ReactQuery.QueryKey) {
+    const getClient = () => this
+
+    return new Proxy<EnhancedQuery<T>>({} as EnhancedQuery<T>, {
+      get(target, p, receiver) {
+
+        const client = getClient()
+
+        // these don't need the actual query
+        switch (p) {
+          case 'key':
+            return key
+          case 'getData':
+            return () => {
+              return client.client.getQueryData<T>(key)
+            }
+          default:
+            break
+        }
+
+        const cache = client.client.getQueryCache()
+
+        const query = cache.find({ exact: true, queryKey: key })
+
+        if (!query) {
+          console.warn(`Attempt to access property ${String(p)} on undefined query with key`, key)
+          return undefined
+        }
+
+        switch (p) {
+
+          case 'waitForRefresh':
+            return () => {
+              return client.waitForRefresh<T>(key)
+            }
+          case 'listen':
+            return (callback: (e: ReactQuery.QueryCacheNotifyEvent) => void) => {
+              return client.listenToQuery(key, callback)
+            }
+          case 'ensureData':
+            return (options) => {
+              return client.client.ensureQueryData<T>({
+                queryKey: key,
+                ...options
+              })
+            }
+          case 'refresh':
+            return async () => {
+              client.client.refetchQueries({
+                exact: true,
+                queryKey: key,
+              })
+              const newQuery = await client.waitForRefresh<T>(key)
+              return newQuery.state.data
+            }
+          case 'poll':
+            return (options: PollQueryOptions<T, any>) => {
+              return client.pollQuery(key, options)
+            }
+          default:
+            return Reflect.get(query, p, receiver)
+        }
+      },
+
+    })
+  }
+
+  waitForRefresh<T>(key: ReactQuery.QueryKey) {
+    const initialQuery = this.client.getQueryCache().find({ exact: true, queryKey: key })
+
+    if (!initialQuery) {
+      return Promise.reject(new Error('Query not found'))
+    }
+
+    const updateTime = initialQuery.state.dataUpdatedAt
+    const errorTime = initialQuery.state.errorUpdatedAt
+
+    return new Promise<ReactQuery.Query<T>>((resolve, reject) => {
+      const removeListener = this.listenToQuery(key, (e) => {
+        const query = e.query
+
+        const isNewer = query.state.dataUpdatedAt > updateTime || query.state.errorUpdatedAt > errorTime
+
+        const isIdle = query.state.fetchStatus === 'idle'
+
+        const isSuccess = query.state.status === 'success'
+        const isError = query.state.status === 'error'
+
+        const isResolved = isSuccess || isError
+
+        if (isNewer && isIdle && isResolved) {
+          if (isSuccess) {
+            resolve(query)
+          } else {
+            reject()
+          }
+
+          removeListener()
+        }
+      })
+    })
+
+  }
+
+  queryKey<Data>(k: ReactQuery.QueryKey, options?: ReactQuery.QueryOptions<Data>) {
+
+    if(options){
+      
+      this.client.setQueryDefaults(k, options)
+
+      const cache = this.client.getQueryCache()
+      
+      const q = new ReactQuery.Query({
+        cache,
+        queryKey: k,
+        queryHash: ReactQuery.hashKey(k),
+        ...options,
+      })
+      
+      cache.add(q)
+    }
+
+    return this.queryProxy<Data>(k)
+  }
+
+  dynamicQueryKey<Data, BuilderArgs extends any[] = any[]>(k: QueryKeyBuilder<BuilderArgs>) {
+
+    const getClient = () => this
+
+    return new Proxy<DynamicEnhancedQuery<Data, BuilderArgs>>({} as DynamicEnhancedQuery<Data, BuilderArgs>, {
+      get(target, p, receiver) {
+        return (...params:BuilderArgs) => {
+          const key = k(...params)
+
+          const proxy = getClient().queryProxy<Data>(key)
+
+          return Reflect.get(proxy, p, receiver)
+        }
+      },
+    })
+  }
+
+  queryManager<T extends QueryManagerItem, Args>(name:string, options: Partial<QueryManagerOptions<T, Args>>) {
+    // @ts-expect-error
+    const m = new QueryManager<T, Args>({
+      name,
+      queryClient: this.client,
+      ...options,
+
+    })
+
+    return m
+  }
+
+}

package/src/types.ts

@@ -0,0 +1,199 @@
+import { DefinedInitialDataInfiniteOptions, InfiniteData, QueryKey, UseInfiniteQueryResult, UseMutationOptions, useQueryClient, UseQueryOptions } from '@tanstack/react-query'
+import { QueryManager } from './QueryManager'
+
+export type PageParam = {limit: number; offset: number}
+
+export type PaginationResponse<T> = {
+  count: number
+  next: string | null
+  previous: string | null
+  results: T[]
+}
+
+type OmitMutationKeys<O> = Omit<O, 'mutationFn'|'mutationKey'>
+
+export type QueryManagerMeta = Record<string, any>
+
+export type CreateOptions<T extends QueryManagerItem> = {
+  appendTo?: 'start' | 'end' | [number, number] | Record<string, [number, number]>
+  optimistic?: boolean
+  mutationOptions?: Partial<OmitMutationKeys<UseMutationOptions<T, unknown, Partial<T>, MutationCtx<T>>>>
+  onListsWithFilters?: any
+}
+
+export type UpdateOptions<T extends QueryManagerItem> = {
+  optimistic?: boolean
+
+  mutationOptions?: Partial<OmitMutationKeys<UseMutationOptions<T, unknown, Partial<T>, MutationCtx<T>>>>
+
+}
+
+export type DeleteOptions<T extends QueryManagerItem> = {
+  optimistic?: boolean
+
+  mutationOptions?: Partial<OmitMutationKeys<UseMutationOptions<T, unknown, T, MutationCtx<T>>>>
+
+}
+
+export type RetrieveOptions<T extends QueryManagerItem> = {
+  queryOptions?: Partial<UseQueryOptions<T, unknown, T>>
+  id?: T['id']
+}
+
+export type ListOptions<T extends QueryManagerItem, ExtraArgs = any> = {
+  queryOptions?: Partial<
+  DefinedInitialDataInfiniteOptions<PaginationResponse<T>, Error, UseListSelector<T>, QueryKey, PageParam>
+  >
+  filter?: ExtraArgs
+  limit?: number
+}
+
+export type QueryManagerAction<
+  T extends QueryManagerItem,
+  ExtraArgs = any,
+  Meta extends QueryManagerMeta = QueryManagerMeta,
+  Args extends any[] = any[]
+> = (
+    manager: QueryManager<T, ExtraArgs, Meta>, ...args: Args
+  ) => any
+
+export type QueryManagerActions<
+  T extends QueryManagerItem,
+  ExtraArgs = any,
+  Meta extends QueryManagerMeta = QueryManagerMeta
+> = Record<
+  string, QueryManagerAction<T, ExtraArgs, Meta>
+>
+
+export type UseListEffect<T extends QueryManagerItem = any> = (
+  listQuery: {
+    query: UseInfiniteQueryResult<UseListSelector<T>, Error>
+    refreshQuery: (silent?: boolean) => void
+    cancelQuery: () => void
+  }
+) => void
+
+export type QueryManagerOptions<
+  T extends QueryManagerItem,
+  ExtraArgs = any,
+  Meta extends QueryManagerMeta = QueryManagerMeta,
+  Actions extends QueryManagerActions<T, ExtraArgs, Meta> = QueryManagerActions<T, ExtraArgs, Meta>
+> = {
+  name: string
+  itemType: T
+  queryClient: ReturnType<typeof useQueryClient>
+
+  listItems?: (limit: number, offset: number, args?: ExtraArgs) => Promise<PaginationResponse<T>>
+  createItem?: (data: Partial<T>, args?: ExtraArgs) => Promise<T>
+  updateItem?: (data: Partial<T>, args?: ExtraArgs) => Promise<T>
+  deleteItem?: (data: T, args?: ExtraArgs) => Promise<T>
+  retrieveItem?: (id: T['id']) => Promise<T>
+
+  useListEffect?: UseListEffect<T>
+
+  limit?: number
+  creation?: CreateOptions<T>
+  update?: UpdateOptions<T>
+  deletion?: DeleteOptions<T>
+  generateId?: () => T['id']
+  actions?: Actions
+  keyExtractor?: (item: T) => string
+  initialMeta?: Meta
+}
+
+export type QueryManagerActionTrigger<
+  A extends QueryManagerAction<any, any, any>,
+  Args extends any[] = A extends QueryManagerAction<any, any, any, infer _Args> ? _Args : any[]
+> = (...args: Args) => any
+
+export type QueryManagerActionTriggers<
+  Actions extends QueryManagerActions<any, any, any>
+> = {
+  [K in keyof Actions]: QueryManagerActionTrigger<Actions[K]>
+}
+
+export type InfinitePaginationData<T> = InfiniteData<PaginationResponse<T>, PageParam>
+
+export type UseManagerArgs<T extends QueryManagerItem, ExtraArgs = any> = {
+  filter?: ExtraArgs
+  limit?: number
+  offset?: number
+
+  creation?: CreateOptions<T>
+  update?: UpdateOptions<T>
+  deletion?: DeleteOptions<T>
+
+  listOptions?: Pick<ListOptions<T, ExtraArgs>, 'queryOptions'>
+}
+
+export type QueryManagerItem = {
+  id: string | number
+}
+
+export type AppendToPaginationParams<TItem extends QueryManagerItem, Filters = any> = {
+  item: TItem|TItem[]
+  to?: CreateOptions<TItem>['appendTo']
+  refreshKey?: QueryKey
+  onListsWithFilters?: Filters
+}
+
+export type AppendToPaginationReturn<TItem = any> = InfiniteData<TItem>
+
+export type AppendToPagination<TItem extends QueryManagerItem, ExtraArgs = any> = (params: AppendToPaginationParams<TItem, ExtraArgs>) => Promise<void>
+
+export type MutationCtx<T extends QueryManagerItem> = null | {
+  previousData?: InfinitePaginationData<T>
+  addedId?: T['id']
+  previousItem?: T
+  optimisticItem?: T
+  prevItemPages?:Record<string, [number, number]>
+}
+
+export const isInfiniteQueryData = <T>(data: any): data is InfinitePaginationData<T> => {
+  return !!data?.pages && !!data?.pageParams
+}
+
+export type QueryStateValue<T extends QueryManagerItem> = {
+  pagesById: Record<T['id'], [number, number]>
+  itemIndexes: Record<T['id'], number>
+  key: QueryKey
+}
+
+export type QueryStateSubscriber<T extends QueryManagerItem> = (data: QueryStateValue<T>) => void
+
+export type FilterKeyOrder = string[]
+
+export type GetItemOptions<T extends QueryManagerItem> = {
+  forceRefetch?: boolean
+  fetchOnNotFoud?: boolean
+}
+
+export type SettableOptions<O extends QueryManagerOptions<any, any, any, any>> = Partial<
+  Pick<
+    O,
+    'limit' |
+    'creation' |
+    'update' |
+    'deletion'
+  > & {
+    meta: O['initialMeta']
+  }
+>
+
+export type OptionChangeListener<O extends QueryManagerOptions<any, any, any, any>> = (
+  options: O,
+  meta: O['initialMeta'],
+) => any
+
+export type UseActionOptions<T extends QueryManagerAction<any, any, any>> = UseMutationOptions<
+  Awaited<ReturnType<T>>,
+  unknown,
+  Parameters<T>[1]
+>
+
+export type UseListSelector<T> = {
+  pageParams: PageParam[]
+  pages: PaginationResponse<T>[]
+  flatItems: T[]
+}
+