eden-tanstack-query 0.0.9 → 0.1.0-alpha.2

package/src/index.ts

@@ -0,0 +1,217 @@
+import type { Elysia } from 'elysia'
+import type { QueryKey, QueryClient } from '@tanstack/query-core'
+import { treaty, type Treaty } from '@elysiajs/eden/treaty2'
+import type { EdenTQ, EdenQueryOptions, EdenMutationOptions } from './types'
+
+const HTTP_METHODS = [
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+    'options',
+    'head'
+] as const
+
+type HttpMethod = (typeof HTTP_METHODS)[number]
+
+function isHttpMethod(value: string): value is HttpMethod {
+    return HTTP_METHODS.includes(value as HttpMethod)
+}
+
+function materializePath(
+    paths: string[],
+    params?: Record<string, string | number>
+): string[] {
+    const result: string[] = []
+
+    for (const segment of paths) {
+        const match = /^:(.+?)(\?)?$/.exec(segment)
+        if (!match) {
+            result.push(segment)
+            continue
+        }
+
+        const paramName = match[1]
+        const isOptional = !!match[2]
+        const value = params?.[paramName]
+
+        if (value == null) {
+            if (isOptional) continue
+            throw new Error(`Missing required route parameter: "${paramName}"`)
+        }
+
+        result.push(String(value))
+    }
+
+    return result
+}
+
+function buildQueryKey(
+    prefix: QueryKey,
+    method: string,
+    pathTemplate: string[],
+    input?: { params?: unknown; query?: unknown }
+): QueryKey {
+    return [
+        ...prefix,
+        method,
+        pathTemplate,
+        input?.params ?? null,
+        input?.query ?? null
+    ] as const
+}
+
+function callTreaty(
+    raw: any,
+    segments: string[],
+    method: string,
+    input?: { body?: unknown; query?: unknown; headers?: unknown; fetch?: RequestInit }
+): Promise<Treaty.TreatyResponse<any>> {
+    let current = raw
+
+    for (const segment of segments) {
+        current = current[segment]
+    }
+
+    const options: Record<string, unknown> = {}
+    if (input?.query !== undefined) options.query = input.query
+    if (input?.headers !== undefined) options.headers = input.headers
+    if (input?.fetch !== undefined) Object.assign(options, input.fetch)
+
+    if (method === 'get' || method === 'head') {
+        return current[method](Object.keys(options).length > 0 ? options : undefined)
+    }
+
+    return current[method](
+        input?.body,
+        Object.keys(options).length > 0 ? options : undefined
+    )
+}
+
+async function dataOrThrow<T>(
+    promise: Promise<Treaty.TreatyResponse<any>>
+): Promise<T> {
+    const result = await promise
+    if (result.error) throw result.error
+    return result.data as T
+}
+
+interface ProxyContext {
+    raw: any
+    prefix: QueryKey
+}
+
+function createMethodDecorator(
+    ctx: ProxyContext,
+    paths: string[],
+    method: string
+) {
+    const pathTemplate = [...paths]
+
+    const fn = (
+        input?: { params?: Record<string, string | number>; body?: unknown; query?: unknown; headers?: unknown; fetch?: RequestInit }
+    ) => {
+        const materializedPath = materializePath(pathTemplate, input?.params)
+        return callTreaty(ctx.raw, materializedPath, method, input)
+    }
+
+    fn.queryKey = (
+        input?: { params?: Record<string, string | number>; query?: unknown }
+    ): QueryKey => {
+        return buildQueryKey(ctx.prefix, method, pathTemplate, input)
+    }
+
+    fn.queryOptions = <TData = unknown>(
+        input: { params?: Record<string, string | number>; query?: unknown; headers?: unknown; fetch?: RequestInit },
+        overrides?: Partial<EdenQueryOptions<TData>>
+    ): EdenQueryOptions<TData> => {
+        return {
+            queryKey: fn.queryKey(input),
+            queryFn: () => {
+                const materializedPath = materializePath(pathTemplate, input?.params)
+                return dataOrThrow(callTreaty(ctx.raw, materializedPath, method, input))
+            },
+            ...overrides
+        }
+    }
+
+    fn.mutationKey = (
+        input?: { params?: Record<string, string | number>; query?: unknown }
+    ): QueryKey => {
+        return buildQueryKey(ctx.prefix, method, pathTemplate, input)
+    }
+
+    fn.mutationOptions = <TData = unknown, TVariables = unknown>(
+        overrides?: Partial<EdenMutationOptions<TData, unknown, TVariables>>
+    ): EdenMutationOptions<TData, unknown, TVariables> => {
+        return {
+            mutationKey: [...ctx.prefix, method, pathTemplate],
+            mutationFn: (variables: TVariables) => {
+                const vars = variables as { params?: Record<string, string | number>; body?: unknown; query?: unknown; headers?: unknown; fetch?: RequestInit }
+                const materializedPath = materializePath(pathTemplate, vars?.params)
+                return dataOrThrow(callTreaty(ctx.raw, materializedPath, method, vars))
+            },
+            ...overrides
+        }
+    }
+
+    fn.invalidate = async (
+        queryClient: QueryClient,
+        input?: { params?: Record<string, string | number>; query?: unknown },
+        exact = false
+    ): Promise<void> => {
+        const queryKey = input
+            ? fn.queryKey(input)
+            : [...ctx.prefix, method, pathTemplate]
+        await queryClient.invalidateQueries({ queryKey, exact })
+    }
+
+    return fn
+}
+
+function createEdenTQProxy(
+    ctx: ProxyContext,
+    paths: string[] = []
+): any {
+    return new Proxy(() => {}, {
+        get(_, prop: string): any {
+            if (isHttpMethod(prop)) {
+                return createMethodDecorator(ctx, paths, prop)
+            }
+
+            return createEdenTQProxy(
+                ctx,
+                prop === 'index' ? paths : [...paths, prop]
+            )
+        },
+        apply(_, __, [body]) {
+            if (typeof body === 'object' && body !== null) {
+                const paramValue = Object.values(body)[0] as string
+                return createEdenTQProxy(ctx, [...paths, paramValue])
+            }
+            return createEdenTQProxy(ctx, paths)
+        }
+    })
+}
+
+export function createEdenTQ<
+    const App extends Elysia<any, any, any, any, any, any, any>
+>(
+    domain: string | App,
+    config: EdenTQ.Config = {}
+): EdenTQ.Create<App> {
+    const { queryKeyPrefix = ['eden'], ...treatyConfig } = config
+
+    const raw = treaty<App>(domain as any, treatyConfig)
+
+    const ctx: ProxyContext = {
+        raw,
+        prefix: queryKeyPrefix
+    }
+
+    return createEdenTQProxy(ctx) as EdenTQ.Create<App>
+}
+
+export type { EdenTQ, EdenQueryOptions, EdenMutationOptions }
+export type { QueryKey, QueryClient } from '@tanstack/query-core'

package/src/types.ts

@@ -0,0 +1,178 @@
+import type { Elysia, ELYSIA_FORM_DATA } from 'elysia'
+import type { QueryKey, QueryClient } from '@tanstack/query-core'
+import type { Treaty } from '@elysiajs/eden/treaty2'
+
+type IsNever<T> = [T] extends [never] ? true : false
+
+type Prettify<T> = {
+    [K in keyof T]: T[K]
+} & {}
+
+type Enumerate<
+    N extends number,
+    Acc extends number[] = []
+> = Acc['length'] extends N
+    ? Acc[number]
+    : Enumerate<N, [...Acc, Acc['length']]>
+
+type IntegerRange<F extends number, T extends number> = Exclude<
+    Enumerate<T>,
+    Enumerate<F>
+>
+
+type SuccessCodeRange = IntegerRange<200, 300>
+
+type ExtractData<Res extends Record<number, unknown>> =
+    Res[Extract<keyof Res, SuccessCodeRange>] extends {
+        [ELYSIA_FORM_DATA]: infer Data
+    }
+        ? Data
+        : Res[Extract<keyof Res, SuccessCodeRange>]
+
+type ExtractError<Res extends Record<number, unknown>> = Exclude<
+    keyof Res,
+    SuccessCodeRange
+> extends never
+    ? { status: unknown; value: unknown }
+    : {
+          [Status in keyof Res]: {
+              status: Status
+              value: Res[Status] extends { [ELYSIA_FORM_DATA]: infer Data }
+                  ? Data
+                  : Res[Status]
+          }
+      }[Exclude<keyof Res, SuccessCodeRange>]
+
+interface TQParamBase {
+    fetch?: RequestInit
+}
+
+type SerializeQueryParams<T> = T extends Record<string, any>
+    ? {
+          [K in keyof T]: T[K] extends Date
+              ? string
+              : T[K] extends Date | undefined
+                  ? string | undefined
+                  : T[K]
+      }
+    : T
+
+type IsEmptyObject<T> = T extends Record<string, never>
+    ? [keyof T] extends [never]
+        ? true
+        : false
+    : false
+
+type MaybeEmptyObject<T, K extends PropertyKey> = [T] extends [never]
+    ? {}
+    : [T] extends [undefined]
+      ? { [P in K]?: T }
+      : IsEmptyObject<T> extends true
+        ? { [P in K]?: T }
+        : undefined extends T
+          ? { [P in K]?: T }
+          : { [P in K]: T }
+
+type TQMethodParam<
+    Body,
+    Headers,
+    Query,
+    Params
+> = MaybeEmptyObject<Headers, 'headers'> &
+    MaybeEmptyObject<SerializeQueryParams<Query>, 'query'> &
+    MaybeEmptyObject<Params, 'params'> &
+    MaybeEmptyObject<Body, 'body'> &
+    TQParamBase
+
+export interface EdenQueryOptions<TData = unknown, TError = unknown> {
+    queryKey: QueryKey
+    queryFn: () => Promise<TData>
+}
+
+export interface EdenMutationOptions<
+    TData = unknown,
+    TError = unknown,
+    TVariables = unknown
+> {
+    mutationKey: QueryKey
+    mutationFn: (variables: TVariables) => Promise<TData>
+}
+
+export interface EdenTQMethod<
+    Body,
+    Headers,
+    Query,
+    Params,
+    Res extends Record<number, unknown>
+> {
+    <TQueryFnData = ExtractData<Res>>(
+        input: TQMethodParam<Body, Headers, Query, Params>,
+        options?: RequestInit
+    ): Promise<Treaty.TreatyResponse<Res>>
+
+    queryKey(input?: TQMethodParam<Body, Headers, Query, Params>): QueryKey
+
+    queryOptions<TData = ExtractData<Res>>(
+        input: TQMethodParam<Body, Headers, Query, Params>,
+        overrides?: Partial<EdenQueryOptions<TData, ExtractError<Res>>>
+    ): EdenQueryOptions<TData, ExtractError<Res>>
+
+    mutationKey(input?: TQMethodParam<Body, Headers, Query, Params>): QueryKey
+
+    mutationOptions<TData = ExtractData<Res>>(
+        overrides?: Partial<EdenMutationOptions<TData, ExtractError<Res>, TQMethodParam<Body, Headers, Query, Params>>>
+    ): EdenMutationOptions<TData, ExtractError<Res>, TQMethodParam<Body, Headers, Query, Params>>
+
+    invalidate(
+        queryClient: QueryClient,
+        input?: TQMethodParam<Body, Headers, Query, Params>,
+        exact?: boolean
+    ): Promise<void>
+}
+
+export namespace EdenTQ {
+    export type Config = Treaty.Config & {
+        queryKeyPrefix?: QueryKey
+    }
+
+    export type Create<App extends Elysia<any, any, any, any, any, any, any>> =
+        App extends {
+            '~Routes': infer Schema extends Record<any, any>
+        }
+            ? Prettify<Sign<Schema>> & CreateParams<Schema>
+            : 'Please install Elysia before using Eden'
+
+    export type Sign<in out Route extends Record<any, any>> = {
+        [K in keyof Route as K extends `:${string}`
+            ? never
+            : K]: Route[K] extends {
+            body: infer Body
+            headers: infer Headers
+            params: infer Params
+            query: infer Query
+            response: infer Res extends Record<number, unknown>
+        }
+            ? EdenTQMethod<Body, Headers, Query, Params, Res>
+            : CreateParams<Route[K]>
+    }
+
+    type CreateParams<Route extends Record<string, any>> =
+        Extract<keyof Route, `:${string}`> extends infer Path extends string
+            ? IsNever<Path> extends true
+                ? Prettify<Sign<Route>>
+                : (((params: {
+                      [param in Path extends `:${infer Param}`
+                          ? Param extends `${infer P}?`
+                              ? P
+                              : Param
+                          : never]: string | number
+                  }) => Prettify<Sign<Route[Path]>> &
+                      CreateParams<Route[Path]>) &
+                      Prettify<Sign<Route>>) &
+                      (Path extends `:${string}?`
+                          ? CreateParams<Route[Path]>
+                          : {})
+            : never
+}
+
+export type { QueryKey, QueryClient }