@elysiajs/eden 0.8.0 → 1.0.0-beta.0

package/src/treaty/index.ts

@@ -1,376 +0,0 @@
-import type { Elysia, InputSchema } from 'elysia'
-
-import { EdenFetchError } from '../errors'
-
-import { composePath } from './utils'
-import type { EdenTreaty } from './types'
-
-export type { EdenTreaty } from './types'
-
-// @ts-ignore
-const isServer = typeof FileList === 'undefined'
-
-const isFile = (v: any) => {
-    // @ts-ignore
-    if (isServer) {
-        return v instanceof Blob
-    } else {
-        // @ts-ignore
-        return v instanceof FileList || v instanceof File
-    }
-}
-
-// FormData is 1 level deep
-const hasFile = (obj: Record<string, any>) => {
-    if (!obj) return false
-
-    for (const key in obj) {
-        if (isFile(obj[key])) return true
-        else if (
-            Array.isArray(obj[key]) &&
-            (obj[key] as unknown[]).find((x) => isFile(x))
-        )
-            return true
-    }
-
-    return false
-}
-
-// @ts-ignore
-const createNewFile = (v: File) =>
-    isServer
-        ? v
-        : new Promise<File>((resolve) => {
-              // @ts-ignore
-              const reader = new FileReader()
-
-              reader.onload = () => {
-                  const file = new File([reader.result!], v.name, {
-                      lastModified: v.lastModified,
-                      type: v.type
-                  })
-                  resolve(file)
-              }
-
-              reader.readAsArrayBuffer(v)
-          })
-
-export class EdenWS<Schema extends InputSchema<any> = InputSchema> {
-    ws: WebSocket
-    url: string
-
-    constructor(url: string) {
-        this.ws = new WebSocket(url)
-        this.url = url
-    }
-
-    send(data: Schema['body'] | Schema['body'][]) {
-        if (Array.isArray(data)) {
-            data.forEach((datum) => this.send(datum))
-
-            return this
-        }
-
-        this.ws.send(
-            typeof data === 'object' ? JSON.stringify(data) : data.toString()
-        )
-
-        return this
-    }
-
-    on<K extends keyof WebSocketEventMap>(
-        type: K,
-        listener: (event: EdenTreaty.WSEvent<K, Schema['response']>) => void,
-        options?: boolean | AddEventListenerOptions
-    ) {
-        return this.addEventListener(type, listener, options)
-    }
-
-    off<K extends keyof WebSocketEventMap>(
-        type: K,
-        listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
-        options?: boolean | EventListenerOptions
-    ) {
-        this.ws.removeEventListener(type, listener, options)
-
-        return this
-    }
-
-    subscribe(
-        onMessage: (
-            event: EdenTreaty.WSEvent<'message', Schema['response']>
-        ) => void,
-        options?: boolean | AddEventListenerOptions
-    ) {
-        return this.addEventListener('message', onMessage, options)
-    }
-
-    addEventListener<K extends keyof WebSocketEventMap>(
-        type: K,
-        listener: (event: EdenTreaty.WSEvent<K, Schema['response']>) => void,
-        options?: boolean | AddEventListenerOptions
-    ) {
-        this.ws.addEventListener(
-            type,
-            (ws) => {
-                if (type === 'message') {
-                    let data = (ws as MessageEvent).data.toString() as any
-                    const start = data.charCodeAt(0)
-
-                    if (start === 47 || start === 123)
-                        try {
-                            data = JSON.parse(data)
-                        } catch {
-                            // Not Empty
-                        }
-                    else if (!Number.isNaN(+data)) data = +data
-                    else if (data === 'true') data = true
-                    else if (data === 'false') data = false
-
-                    listener({
-                        ...ws,
-                        data
-                    } as any)
-                } else listener(ws as any)
-            },
-            options
-        )
-
-        return this
-    }
-
-    removeEventListener<K extends keyof WebSocketEventMap>(
-        type: K,
-        listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
-        options?: boolean | EventListenerOptions
-    ) {
-        this.off(type, listener, options)
-
-        return this
-    }
-
-    close() {
-        this.ws.close()
-
-        return this
-    }
-}
-
-const createProxy = (
-    domain: string,
-    path = '',
-    config: EdenTreaty.Config
-): Record<string, unknown> =>
-    new Proxy(() => {}, {
-        get(target, key, value) {
-            return createProxy(domain, `${path}/${key.toString()}`, config)
-        },
-        // @ts-ignore
-        apply(
-            target,
-            _,
-            [initialBody, options = {}]: [
-                {
-                    [x: string]: any
-                    $fetch?: RequestInit
-                    $headers?: HeadersInit
-                    $query?: Record<string, string>
-                    getRaw?: boolean
-                },
-                {
-                    fetch?: RequestInit
-                    transform?: EdenTreaty.Transform
-                    headers?: Record<string, string>
-                    query?: Record<string, string | number>
-                }
-            ] = [{}, {}]
-        ) {
-            let bodyObj: any =
-                initialBody !== undefined &&
-                (typeof initialBody !== 'object' || Array.isArray(initialBody))
-                    ? initialBody
-                    : undefined
-
-            const { $query, $fetch, $headers, $transform, getRaw, ...restBody } =
-                initialBody ?? {}
-
-            bodyObj ??= restBody
-
-            const i = path.lastIndexOf('/'),
-                method = path.slice(i + 1).toUpperCase(),
-                url = composePath(
-                    domain,
-                    i === -1 ? '/' : path.slice(0, i),
-                    Object.assign(options.query ?? {}, $query)
-                )
-
-            const fetcher = config.fetcher ?? fetch
-            let transforms = config.transform
-                ? Array.isArray(config.transform)
-                    ? config.transform
-                    : [config.transform]
-                : undefined
-
-            const $transforms = $transform
-                ? Array.isArray($transform)
-                    ? $transform
-                    : [$transform]
-                : undefined
-
-            if ($transforms) {
-                if (transforms) transforms = $transforms.concat(transforms)
-                else transforms = $transforms as any
-            }
-
-            if (method === 'SUBSCRIBE')
-                return new EdenWS(
-                    url.replace(
-                        /^([^]+):\/\//,
-                        url.startsWith('https://') ? 'wss://' : 'ws://'
-                    )
-                )
-
-            const execute = async <T extends EdenTreaty.ExecuteOptions>(modifiers: T): Promise<EdenTreaty.ExecuteReturnType<T>> => {
-                let body: any
-
-                const headers = {
-                    ...config.$fetch?.headers,
-                    ...$fetch?.headers,
-                    ...options.headers,
-                    ...$headers
-                } as Record<string, string>
-
-                if (method !== 'GET' && method !== 'HEAD') {
-                    body = Object.keys(bodyObj).length
-                        ? bodyObj
-                        : Array.isArray(bodyObj)
-                          ? bodyObj
-                          : undefined
-
-                    const isObject =
-                        typeof body === 'object' || Array.isArray(bodyObj)
-                    const isFormData = isObject && hasFile(body)
-
-                    if (isFormData) {
-                        const newBody = new FormData()
-
-                        // FormData is 1 level deep
-                        for (const [key, field] of Object.entries(body)) {
-                            if (isServer) {
-                                newBody.append(key, field as any)
-                            } else {
-                                // @ts-ignore
-                                if (field instanceof File)
-                                    newBody.append(
-                                        key,
-                                        await createNewFile(field as any)
-                                    )
-                                // @ts-ignore
-                                else if (field instanceof FileList) {
-                                    // @ts-ignore
-                                    for (let i = 0; i < field.length; i++) {
-                                        newBody.append(
-                                            key as any,
-                                            await createNewFile(
-                                                (field as any)[i]
-                                            )
-                                        )
-                                    }
-                                } else if (Array.isArray(field)) {
-                                    for (let i = 0; i < field.length; i++) {
-                                        const value = (field as any)[i]
-
-                                        newBody.append(
-                                            key as any,
-                                            value instanceof File
-                                                ? await createNewFile(value)
-                                                : value
-                                        )
-                                    }
-                                } else newBody.append(key, field as string)
-                            }
-                        }
-
-                        body = newBody
-                    } else {
-                        headers['content-type'] = isObject
-                            ? 'application/json'
-                            : 'text/plain'
-
-                        body = isObject ? JSON.stringify(body) : bodyObj
-                    }
-                }
-
-                const response = await fetcher(url, {
-                    method,
-                    body,
-                    ...config.$fetch,
-                    ...options.fetch,
-                    ...$fetch,
-                    headers
-                })
-
-                let data
-
-                if (modifiers.getRaw) return response as any
-                switch (response.headers.get('Content-Type')?.split(';')[0]) {
-                    case 'application/json':
-                        data = await response.json()
-                        break
-
-                    default:
-                        data = await response.text().then((data) => {
-                            if (!Number.isNaN(+data)) return +data
-                            if (data === 'true') return true
-                            if (data === 'false') return false
-
-                            return data
-                        })
-                }
-
-                const error =
-                    response.status >= 300 || response.status < 200
-                        ? new EdenFetchError(response.status, data)
-                        : null
-
-                if (transforms)
-                    for (const transform of transforms) {
-                        let temp = transform({
-                            data,
-                            status: response.status,
-                            headers: response.headers,
-                            response,
-                            error
-                        })
-                        if (temp instanceof Promise) temp = await temp
-
-                        if (temp !== undefined && temp !== null) data = temp
-                    }
-
-                return {
-                    data,
-                    error,
-                    response: response,
-                    status: response.status,
-                    headers: response.headers
-                } as any
-            }
-
-            return execute({ getRaw })
-        }
-    }) as unknown as Record<string, unknown>
-
-export const edenTreaty = <App extends Elysia<any, any, any, any, any, any>>(
-    domain: string,
-    config: EdenTreaty.Config = {
-        fetcher: fetch
-    }
-): EdenTreaty.Create<App> =>
-    new Proxy(
-        {},
-        {
-            get(target, key) {
-                return createProxy(domain, key as string, config)
-            }
-        }
-    ) as any

package/src/treaty/types.ts

@@ -1,219 +0,0 @@
-/// <reference lib="dom" />
-import type { Elysia } from 'elysia'
-import type { EdenWS } from './index'
-import type {
-    IsUnknown,
-    IsNever,
-    IsAny,
-    UnionToIntersect,
-    MapError
-} from '../types'
-import type { EdenFetchError } from '../errors'
-
-type Files = File | FileList
-
-type Replace<RecordType, TargetType, GenericType> = {
-    [K in keyof RecordType]: RecordType[K] extends TargetType
-        ? GenericType
-        : RecordType[K]
-}
-
-type Split<S extends string> = S extends `${infer Head}/${infer Tail}`
-    ? Head extends ''
-        ? Tail extends ''
-            ? []
-            : Split<Tail>
-        : [Head, ...Split<Tail>]
-    : S extends `/`
-      ? []
-      : S extends `${infer Head}/`
-        ? [Head]
-        : [S]
-
-type Prettify<T> = {
-    [K in keyof T]: T[K]
-} & {}
-
-type AnySchema = {
-    body: unknown
-    headers: unknown
-    query: unknown
-    params: unknown
-    response: any
-}
-
-type MaybeArray<T> = T | T[]
-
-export namespace EdenTreaty {
-    export type Create<App extends Elysia<any, any, any, any, any, any>> =
-        App extends {
-            schema: infer Schema extends Record<string, any>
-        }
-            ? UnionToIntersect<Sign<Schema>>
-            : 'Please install Elysia before using Eden'
-
-    type SplitKeys<T> = T extends [infer First, ...infer Rest]
-        ? [First, Rest]
-        : T extends [infer First, ...infer Rest][number]
-          ? [First, Rest]
-          : never
-
-    type UnwrapPromise<T> = T extends Promise<infer A> ? A : T
-
-    export type Transform<T = unknown> = MaybeArray<
-        (
-            response: unknown extends T
-                ? {
-                      data: any
-                      error: any
-                      response: Response
-                      status: number
-                      headers: Headers
-                  }
-                : UnwrapPromise<T>
-        ) => UnwrapPromise<T> | void
-    >
-
-    export interface Config {
-        /**
-         * Default options to pass to fetch
-         */
-        $fetch?: RequestInit
-        fetcher?: typeof fetch
-        transform?: Transform
-    }
-
-    export type DetailedResponse = {
-      data: any
-      error: any
-      response: Response
-      status: number
-      headers: Headers
-    };
-
-    export type Sign<
-        Schema extends Record<string, Record<string, unknown>>,
-        Paths extends (string | number)[] = Split<keyof Schema & string>,
-        Carry extends string = ''
-    > = Paths extends [
-        infer Prefix extends string | number,
-        ...infer Rest extends (string | number)[]
-    ]
-        ? {
-              [Key in Prefix as Prefix extends `:${string}`
-                  ? (string & {}) | number | Prefix
-                  : Prefix]: Sign<Schema, Rest, `${Carry}/${Key}`>
-          }
-        : Schema[Carry extends '' ? '/' : Carry] extends infer Routes
-          ? {
-                [Method in keyof Routes]: Routes[Method] extends infer Route extends
-                    AnySchema
-                    ? Method extends 'subscribe'
-                        ? undefined extends Route['query']
-                            ? (params?: {
-                                  $query?: Record<string, string>
-                              }) => EdenWS<Route>
-                            : (params: {
-                                  $query: Route['query']
-                              }) => EdenWS<Route>
-                        : ((
-                                params: {
-                                    $fetch?: RequestInit
-                                    getRaw?: boolean
-                                } & (IsUnknown<Route['body']> extends false
-                                    ? Replace<
-                                          Route['body'],
-                                          Blob | Blob[],
-                                          Files
-                                      >
-                                    : {}) &
-                                    (undefined extends Route['query']
-                                        ? {
-                                              $query?: Record<string, string>
-                                          }
-                                        : {
-                                              $query: Route['query']
-                                          }) &
-                                    (undefined extends Route['headers']
-                                        ? {
-                                              $headers?: Record<string, unknown>
-                                          }
-                                        : {
-                                              $headers: Route['headers']
-                                          })
-                            ) => Promise<
-                                (
-                                    | {
-                                          data: Route['response'] extends {
-                                              200: infer ReturnedType
-                                          }
-                                              ? Awaited<ReturnedType>
-                                              : unknown
-                                          error: null
-                                      }
-                                    | {
-                                          data: null
-                                          error: MapError<
-                                              Route['response']
-                                          > extends infer Errors
-                                              ? IsNever<Errors> extends true
-                                                  ? EdenFetchError<
-                                                        number,
-                                                        string
-                                                    >
-                                                  : Errors
-                                              : EdenFetchError<number, string>
-                                      }
-                                ) & {
-                                    status: number
-                                    response: Response
-                                    headers: Record<string, string>
-                                }
-                            >) extends (params: infer Params) => infer Response
-                          ? {
-                                $params: undefined
-                                $headers: undefined
-                                $query: undefined
-                            } extends Params
-                              ? (
-                                    params?: Params,
-                                    options?: {
-                                        fetch?: RequestInit
-                                        transform?: EdenTreaty.Transform<Response>
-                                        // @ts-ignore
-                                        query?: Params['query']
-                                        // @ts-ignore
-                                        headers?: Params['headers']
-                                    }
-                                ) => Response
-                              : (
-                                    params: Params,
-                                    options?: {
-                                        fetch?: RequestInit
-                                        transform?: EdenTreaty.Transform<Response>
-                                        // @ts-ignore
-                                        query?: Params['query']
-                                        // @ts-ignore
-                                        headers?: Params['headers']
-                                    }
-                                ) => Response
-                          : never
-                    : never
-            }
-          : {}
-
-    export interface OnMessage<Data = unknown> extends MessageEvent {
-        data: Data
-        rawData: MessageEvent['data']
-    }
-
-    export type ExecuteOptions = {
-      getRaw?: boolean
-    };
-    export type ExecuteReturnType<T extends ExecuteOptions> = T['getRaw'] extends true ? Response : DetailedResponse;
-
-    export type WSEvent<
-        K extends keyof WebSocketEventMap,
-        Data = unknown
-    > = K extends 'message' ? OnMessage<Data> : WebSocketEventMap[K]
-}

package/src/treaty/utils.ts

@@ -1,15 +0,0 @@
-export const composePath = (
-    domain: string,
-    path: string,
-    query: Record<string, string> | undefined
-) => {
-    if (!domain.endsWith('/')) domain += '/'
-    if (path === 'index') path = ''
-
-    if (!query || !Object.keys(query).length) return `${domain}${path}`
-
-    let q = ''
-    for (const [key, value] of Object.entries(query)) q += `${key}=${value}&`
-
-    return `${domain}${path}?${q.slice(0, -1)}`
-}

package/src/types.ts

@@ -1,58 +0,0 @@
-import type { EdenFetchError } from './errors'
-
-// https://stackoverflow.com/a/39495173
-type Range<F extends number, T extends number> = Exclude<
-    Enumerate<T>,
-    Enumerate<F>
->
-
-type Enumerate<
-    N extends number,
-    Acc extends number[] = []
-> = Acc['length'] extends N
-    ? Acc[number]
-    : Enumerate<N, [...Acc, Acc['length']]>
-
-type ErrorRange = Range<300, 599>
-
-export type MapError<T extends Record<number, unknown>> = [
-    {
-        [K in keyof T]-?: K extends ErrorRange ? K : never
-    }[keyof T]
-] extends [infer A extends number]
-    ? {
-          [K in A]: EdenFetchError<K, T[K]>
-      }[A]
-    : false
-
-export type UnionToIntersect<U> = (
-    U extends any ? (arg: U) => any : never
-) extends (arg: infer I) => void
-    ? I
-    : never
-
-export type UnionToTuple<T> = UnionToIntersect<
-    T extends any ? (t: T) => T : never
-> extends (_: any) => infer W
-    ? [...UnionToTuple<Exclude<T, W>>, W]
-    : []
-
-export type IsAny<T> = 0 extends 1 & T ? true : false
-
-export type IsNever<T> = [T] extends [never] ? true : false
-
-export type IsUnknown<T> = IsAny<T> extends true
-    ? false
-    : unknown extends T
-    ? true
-    : false
-
-export type AnyTypedRoute = {
-    body: unknown
-    headers: Record<string, any> | undefined
-    query: Record<string, any> | undefined
-    params: Record<string, any> | undefined
-    response: Record<string, unknown> & {
-        '200': unknown
-    }
-}