@elysiajs/eden 0.3.0-exp-230224.1831 → 0.3.0-rc.0

package/src/index.ts

@@ -1,253 +1,34 @@
-import type { Elysia, TypedSchema, HTTPMethod } from 'elysia'
-
-import type {
-    CreateEden,
-    Eden,
-    EdenCall,
-    EdenConfig,
-    EdenWSEvent,
-    UnionToIntersection
-} from './types'
-import { composePath, EdenFetchError, Signal } from './utils'
-
-export class EdenWS<Schema extends TypedSchema<any> = TypedSchema> {
-    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: EdenWSEvent<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
-    }
-
-    addEventListener<K extends keyof WebSocketEventMap>(
-        type: K,
-        listener: (event: EdenWSEvent<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 {}
-                    else if (!Number.isNaN(+data)) data = +data
-                    else if (data === 'true') data = true
-                    else if (data === 'fase') data = false
-
-                    // @ts-ignore
-                    listener({
-                        ...ws,
-                        data
-                    })
-                } else {
-                    // @ts-ignore
-                    listener(ws)
-                }
-            },
-            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 createFn = (
-    domain: string,
-    procedure: string[],
-    signal: Signal
-): Record<string, unknown> =>
-    // @ts-ignore
-    new Proxy((...v: any[]) => {}, {
-        get(target, key, value) {
-            return createFn(domain, [...procedure, key as string], signal)
-        },
-        apply(target, _, params) {
-            const param = params[0]
-
-            if (procedure.length === 1) {
-                if (
-                    procedure[0] in Object.prototype ||
-                    procedure[0] in Promise.prototype
-                )
-                    return target(params)
-
-                switch (procedure[0]) {
-                    case 'toJSON':
-                        return target(params)
-
-                    case '$set':
-                        return signal.setConfig(param)
-
-                    case '$clone':
-                        return createFn(domain, [], signal.clone(param))
-                }
-            }
-
-            return signal.run(procedure, params).then((result) => {
-                if (result instanceof Error) throw result
-
-                return result
-            })
-        }
-    })
-
-const createProxy = (
-    domain: string,
-    path: string = '',
-    config: EdenConfig
-): Record<string, unknown> =>
-    new Proxy(() => {}, {
-        get(target, key, value) {
-            return createProxy(domain, `${path}/${key.toString()}`, config)
-        },
-        apply(
-            target,
-            _,
-            [
-                { $query, $fetch, $body, ...bodyObj } = {
-                    $fetch: undefined,
-                    $query: undefined,
-                    $body: undefined
-                }
-            ]: EdenCall[] = [{}]
-        ) {
-            const i = path.lastIndexOf('/'),
-                method = path.slice(i + 1),
-                url = composePath(domain, path.slice(0, i), $query)
-
-            if (method === 'subscribe')
-                return new EdenWS(
-                    url.replace(
-                        /^([^]+):\/\//,
-                        url.startsWith('https://') ? 'wss://' : 'ws://'
-                    )
-                )
-
-            const body =
-                $body ?? (Object.keys(bodyObj).length ? bodyObj : undefined)
-            const isObject = typeof body === 'object'
-
-            return fetch(url, {
-                method,
-                body: isObject ? JSON.stringify(body) : body,
-                ...config.fetch,
-                ...$fetch,
-                headers: body
-                    ? {
-                          'content-type': isObject
-                              ? 'application/json'
-                              : 'text/plain',
-                          ...config.fetch?.headers,
-                          ...$fetch?.['headers']
-                      }
-                    : undefined
-            }).then(async (res) => {
-                if (res.status > 300) {
-                    let data
-
-                    if (
-                        res.headers
-                            .get('content-type')
-                            ?.includes('application/json')
-                    )
-                        try {
-                            data = await res.json()
-                        } catch (_) {
-                            data = await res.text()
-                        }
-                    else data = await res.text()
-
-                    return new EdenFetchError(res.status, data)
-                }
-
-                if (
-                    res.headers
-                        .get('content-type')
-                        ?.includes('application/json')
-                )
-                    try {
-                        return await res.json()
-                    } catch (_) {
-                        // if json is error then it's string
-                        // flow down
-                    }
-
-                let data = await res.text()
-
-                if (!Number.isNaN(+data)) return +data
-                if (data === 'true') return true
-                if (data === 'false') return false
-
-                return data
-            })
-        }
-    }) as unknown as Record<string, unknown>
-
-export const eden = <App extends Elysia<any>>(
-    domain: string,
-    config: EdenConfig = {}
-): Eden<App> =>
-    new Proxy(
-        {},
-        {
-            get(target, key) {
-                if (key === '$fn')
-                    return createFn(domain, [], new Signal(domain, config))
-
-                return createProxy(domain, key as string, config)
-            }
-        }
-    ) as any
+import type { Elysia } from 'elysia'
+
+import type { EdenTreaty } from './treaty'
+import type { EdenFetch } from './fetch'
+import type { EdenFn } from './fn'
+
+export { edenTreaty } from './treaty'
+export { edenFetch } from './fetch'
+export { edenFn } from './fn'
+
+// @ts-ignore
+// export const eden: Eden = (domain: string) => ({
+//     treaty(config) {
+//         return import('./treaty').then((x) => x.edenTreaty(domain, config))
+//     },
+//     fn(config) {
+//         return import('./fn').then((x) => x.edenFn(domain, config))
+//     },
+//     fetch(config) {
+//         return import('./fetch').then((x) => x.edenFetch(domain, config))
+//     }
+// })
+
+// type Eden = (domain: string) => {
+//     treaty<App extends Elysia<any>>(
+//         config?: EdenTreaty.Config
+//     ): EdenTreaty.Create<App>
+
+//     fetch<App extends Elysia<any>>(
+//         config?: EdenFetch.Config
+//     ): EdenFetch.Create<App>
+
+//     fn<App extends Elysia<any>>(config?: EdenFn.Config): EdenFn.Create<App>
+// }

package/src/treaty/index.ts

@@ -0,0 +1,192 @@
+import type { Elysia, TypedSchema } from 'elysia'
+
+import { EdenFetchError } from '../utils'
+
+import { composePath } from './utils'
+import type { EdenTreaty } from './types'
+
+export type { EdenTreaty } from './types'
+
+export class EdenWS<Schema extends TypedSchema<any> = TypedSchema> {
+    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
+    }
+
+    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 {}
+                    else if (!Number.isNaN(+data)) data = +data
+                    else if (data === 'true') data = true
+                    else if (data === 'fase') data = false
+
+                    // @ts-ignore
+                    listener({
+                        ...ws,
+                        data
+                    })
+                } else {
+                    // @ts-ignore
+                    listener(ws)
+                }
+            },
+            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: string = '',
+    config: {}
+): Record<string, unknown> =>
+    new Proxy(() => {}, {
+        get(target, key, value) {
+            return createProxy(domain, `${path}/${key.toString()}`, config)
+        },
+        apply(
+            target,
+            _,
+            [
+                { $query, $fetch, $body, ...bodyObj } = {
+                    $fetch: undefined,
+                    $query: undefined,
+                    $body: undefined
+                }
+            ]: EdenTreaty.CallOption[] = [{}]
+        ) {
+            const i = path.lastIndexOf('/'),
+                method = path.slice(i + 1),
+                url = composePath(domain, path.slice(0, i), $query)
+
+            if (method === 'subscribe')
+                return new EdenWS(
+                    url.replace(
+                        /^([^]+):\/\//,
+                        url.startsWith('https://') ? 'wss://' : 'ws://'
+                    )
+                )
+
+            const body =
+                $body ?? (Object.keys(bodyObj).length ? bodyObj : undefined)
+            const isObject = typeof body === 'object'
+
+            return fetch(url, {
+                method,
+                body: isObject ? JSON.stringify(body) : body,
+                // ...config.fetch,
+                ...$fetch,
+                headers: body
+                    ? {
+                          'content-type': isObject
+                              ? 'application/json'
+                              : 'text/plain',
+                          //   ...config.fetch?.headers,
+                          ...$fetch?.['headers']
+                      }
+                    : undefined
+            }).then(async (res) => {
+                let data: Promise<unknown>
+
+                switch (res.headers.get('Content-Type')?.split(';')[0]) {
+                    case 'application/json':
+                        data = res.json()
+                        break
+
+                    default:
+                        data = res.text().then((data) => {
+                            if (!Number.isNaN(+data)) return +data
+                            if (data === 'true') return true
+                            if (data === 'false') return false
+
+                            return data
+                        })
+                }
+
+                if (res.status > 300)
+                    return new EdenFetchError(res.status, await data)
+
+                return data
+            })
+        }
+    }) as unknown as Record<string, unknown>
+
+export const edenTreaty = <App extends Elysia<any>>(
+    domain: string,
+    config: {} = {}
+): EdenTreaty.Create<App> =>
+    new Proxy(
+        {},
+        {
+            get(target, key) {
+                return createProxy(domain, key as string, config)
+            }
+        }
+    ) as any
+

package/src/treaty/types.ts

@@ -0,0 +1,140 @@
+import type { Elysia, SCHEMA, AnyTypedSchema } from 'elysia'
+
+import type { EdenWS } from './index'
+import type { IsNever, IsUnknown, MapError, UnionToIntersect } from '../types'
+import { EdenFetchError } from '../utils'
+
+export namespace EdenTreaty {
+    export type Create<App extends Elysia<any>> = App['meta'] extends Record<
+        typeof SCHEMA,
+        infer Schema extends Record<string, any>
+    >
+        ? EdenTreaty.Sign<Schema>
+        : 'Please install Elysia before using Eden'
+
+    export interface Config {}
+
+    export type Sign<A> = {
+        [Path in keyof A as Path extends `/${infer Prefix}/${infer _}`
+            ? Prefix
+            : Path extends `/`
+            ? 'index'
+            : Path extends `/${infer Prefix}`
+            ? Prefix
+            : never]: UnionToIntersect<
+            Path extends `/${infer _}/${infer Rest}`
+                ? NestPath<
+                      Rest,
+                      {
+                          [Method in keyof A[Path]]: A[Path][Method] extends infer Route extends AnyTypedSchema
+                              ? Method extends 'subscribe'
+                                  ? undefined extends Route['query']
+                                      ? (params?: {
+                                            $query?: Record<string, string>
+                                        }) => EdenWS<Route>
+                                      : undefined extends Route['query']
+                                      ? (params: {
+                                            $query: Route['query']
+                                        }) => EdenWS<Route>
+                                      : (params?: {
+                                            $query?: Record<string, string>
+                                        }) => EdenWS<Route>
+                                  : IsUnknown<Route['body']> extends true
+                                  ? (params?: {
+                                        $query?: Record<string, string>
+                                        $fetch?: RequestInit
+                                    }) =>
+                                        | Promise<Route['response']['200']>
+                                        | (MapError<
+                                              Route['response']
+                                          > extends infer Errors
+                                              ? IsNever<Errors> extends true
+                                                  ? EdenFetchError<
+                                                        number,
+                                                        string
+                                                    >
+                                                  : Errors
+                                              : never)
+                                  : (
+                                        params: Route['body'] & {
+                                            $query?: Record<string, string>
+                                            $fetch?: RequestInit
+                                        }
+                                    ) => Promise<
+                                        Route['response'] extends {
+                                            200: infer ReturnedType
+                                        }
+                                            ? ReturnedType
+                                            : unknown
+                                    >
+                              : never
+                      }
+                  >
+                : {
+                      [Method in keyof A[Path]]: A[Path][Method] extends infer Route extends AnyTypedSchema
+                          ? Method extends 'subscribe'
+                              ? IsUnknown<Route['query']> extends true
+                                  ? (params?: {
+                                        $query?: Record<string, string>
+                                    }) => EdenWS<Route>
+                                  : undefined extends Route['query']
+                                  ? (params: {
+                                        $query: Route['query']
+                                    }) => EdenWS<Route>
+                                  : (params?: {
+                                        $query?: Record<string, string>
+                                    }) => EdenWS<Route>
+                              : IsUnknown<Route['body']> extends true
+                              ? (params?: {
+                                    $query?: Record<string, string>
+                                    $fetch?: RequestInit
+                                }) =>
+                                    | Promise<Route['response']['200']>
+                                    | (MapError<
+                                          Route['response']
+                                      > extends infer Errors
+                                          ? IsNever<Errors> extends true
+                                              ? EdenFetchError<number, string>
+                                              : Errors
+                                          : never)
+                              : (
+                                    params: Route['body'] & {
+                                        $query?: Record<string, string>
+                                        $fetch?: RequestInit
+                                    }
+                                ) => Promise<
+                                    Route['response'] extends {
+                                        200: infer ReturnedType
+                                    }
+                                        ? ReturnedType
+                                        : unknown
+                                >
+                          : never
+                  }
+        >
+    }
+
+    export interface OnMessage<Data = unknown> extends MessageEvent {
+        data: Data
+        rawData: MessageEvent['data']
+    }
+
+    export type WSEvent<
+        K extends keyof WebSocketEventMap,
+        Data = unknown
+    > = K extends 'message' ? OnMessage<Data> : WebSocketEventMap[K]
+
+    export interface CallOption {
+        [x: string]: any
+        $fetch?: RequestInit
+        $query?: Record<string, string>
+    }
+}
+
+type NestPath<T extends string, V> = T extends `${infer First}/${infer Rest}`
+    ? First extends `:${infer Parameter}`
+        ? Record<(string & {}) | `:${Parameter}`, NestPath<Rest, V>>
+        : Record<First, NestPath<Rest, V>>
+    : T extends `:${infer Parameter}`
+    ? Record<(string & {}) | T, V>
+    : Record<T, V>

package/src/treaty/utils.ts

@@ -0,0 +1,15 @@
+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)}`
+}