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

package/dist/treaty.mjs

@@ -0,0 +1,111 @@
+import { E as p } from "./utils-0d2b8b1a.mjs";
+const E = (n, e, t) => {
+  if (n.endsWith("/") || (n += "/"), e === "index" && (e = ""), !t || !Object.keys(t).length)
+    return `${n}${e}`;
+  let s = "";
+  for (const [i, r] of Object.entries(t))
+    s += `${i}=${r}&`;
+  return `${n}${e}?${s.slice(0, -1)}`;
+};
+class N {
+  constructor(e) {
+    this.ws = new WebSocket(e), this.url = e;
+  }
+  send(e) {
+    return Array.isArray(e) ? (e.forEach((t) => this.send(t)), this) : (this.ws.send(
+      typeof e == "object" ? JSON.stringify(e) : e.toString()
+    ), this);
+  }
+  on(e, t, s) {
+    return this.addEventListener(e, t, s);
+  }
+  off(e, t, s) {
+    return this.ws.removeEventListener(e, t, s), this;
+  }
+  addEventListener(e, t, s) {
+    return this.ws.addEventListener(
+      e,
+      (i) => {
+        if (e === "message") {
+          let r = i.data.toString();
+          const o = r.charCodeAt(0);
+          if (o === 47 || o === 123)
+            try {
+              r = JSON.parse(r);
+            } catch {
+            }
+          else
+            Number.isNaN(+r) ? r === "true" ? r = !0 : r === "fase" && (r = !1) : r = +r;
+          t({
+            ...i,
+            data: r
+          });
+        } else
+          t(i);
+      },
+      s
+    ), this;
+  }
+  removeEventListener(e, t, s) {
+    return this.off(e, t, s), this;
+  }
+  close() {
+    return this.ws.close(), this;
+  }
+}
+const b = (n, e = "", t) => new Proxy(() => {
+}, {
+  get(s, i, r) {
+    return b(n, `${e}/${i.toString()}`);
+  },
+  apply(s, i, [
+    { $query: r, $fetch: o, $body: w, ...h } = {
+      $fetch: void 0,
+      $query: void 0,
+      $body: void 0
+    }
+  ] = [{}]) {
+    const d = e.lastIndexOf("/"), y = e.slice(d + 1), a = E(n, e.slice(0, d), r);
+    if (y === "subscribe")
+      return new N(
+        a.replace(
+          /^([^]+):\/\//,
+          a.startsWith("https://") ? "wss://" : "ws://"
+        )
+      );
+    const f = w ?? (Object.keys(h).length ? h : void 0), g = typeof f == "object";
+    return fetch(a, {
+      method: y,
+      body: g ? JSON.stringify(f) : f,
+      // ...config.fetch,
+      ...o,
+      headers: f ? {
+        "content-type": g ? "application/json" : "text/plain",
+        //   ...config.fetch?.headers,
+        ...o == null ? void 0 : o.headers
+      } : void 0
+    }).then(async (c) => {
+      var v;
+      let l;
+      switch ((v = c.headers.get("Content-Type")) == null ? void 0 : v.split(";")[0]) {
+        case "application/json":
+          l = c.json();
+          break;
+        default:
+          l = c.text().then((u) => Number.isNaN(+u) ? u === "true" ? !0 : u === "false" ? !1 : u : +u);
+      }
+      return c.status > 300 ? new p(c.status, await l) : l;
+    });
+  }
+}), x = (n, e = {}) => new Proxy(
+  {},
+  {
+    get(t, s) {
+      return b(n, s);
+    }
+  }
+);
+export {
+  N as EdenWS,
+  x as edenTreaty
+};

package/dist/types.d.ts

@@ -1,89 +1,25 @@
-/// <reference types="bun-types" />
-import type { Elysia, SCHEMA, TypedRoute, IsPathParameter, EXPOSED } from 'elysia';
-import type { EdenWS } from '.';
-import { type EdenFetchError } from './utils';
-declare type IsAny<T> = unknown extends T ? [T] extends [object] ? true : false : false;
-declare type Promisify<T extends (...args: any[]) => any> = T extends (...args: infer Args) => infer Return ? Return extends Promise<any> ? T : (...args: Args) => Promise<Return> : never;
-declare type Asynctify<T> = T extends infer Fn extends (...args: any) => any ? Promisify<Fn> : T extends Record<string, any> ? {
-    [K in keyof T]: EdenFn<T[K]>;
-} : never;
-declare type EdenFn<T> = T extends {
-    [EXPOSED]: any;
-    value: infer Value;
-} ? Asynctify<Value> : Asynctify<T>;
-declare type CreateEdenFn<Exposed extends Record<string, any>> = EdenFn<Exposed> & {
-    $set(config: EdenConfig): void;
-    $clone(config?: EdenConfig): CreateEdenFn<Exposed>;
-};
-export declare type Eden<App extends Elysia<any>> = App['store'] extends {
-    [key in typeof SCHEMA]: any;
-} ? IsAny<Elysia> extends true ? 'Please install Elysia before using Eden' : UnionToIntersection<CreateEden<App['store'][typeof SCHEMA]>> & {
-    $fn: CreateEdenFn<App['store'][typeof EXPOSED]>;
-} : never;
-export interface EdenCall {
-    [x: string]: any;
-    $fetch?: RequestInit;
-    $query?: Record<string, string | boolean | number>;
-}
-export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-declare type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-declare type TypedRouteToParams<Route extends TypedRoute> = (Route['body'] extends NonNullable<Route['body']> ? Route['body'] extends Record<any, any> ? Route['body'] : {
-    $body: Route['body'];
-} : {}) & (Route['query'] extends NonNullable<Route['query']> ? unknown extends Route['query'] ? {} : {
-    $query: Route['query'];
-} : {});
-export declare type CreateEden<Server extends Record<string, Record<string, TypedRoute>>, Path extends string = keyof Server extends string ? keyof Server : never, Full extends string = ''> = Path extends `/${infer Start}` ? CreateEden<Server, Start, Path> : Path extends `${infer A}/${infer B}` ? IsPathParameter<A> extends never ? {
-    [key in A]: CreateEden<Server, B, Full>;
-} : Record<string, CreateEden<Server, B, Full>> & Record<`$${A}`, `Expected path parameters ':${A}', replace this with any string`> : // Iterate until last string then catch method
-{
-    [key in Path extends '' ? 'index' : Path extends `:${infer params}` ? string : Path | CamelCase<Path>]: Full extends keyof Server ? {
-        [key in keyof Server[Full] extends string ? Lowercase<keyof Server[Full]> : keyof Server[Full]]: [
-            Server[Full][key extends string ? Uppercase<key> : key]
-        ] extends [infer Route extends TypedRoute] ? undefined extends Route['body'] ? (params?: {
-            $query?: EdenCall['$query'];
-            $fetch?: EdenCall['$fetch'];
-        }) => Promise<Route['response'] extends {
-            200: infer ReturnedType;
-        } ? ReturnedType | MapError<Route['response']> : unknown> : (params: Prettify<TypedRouteToParams<Route> & {
-            $query?: EdenCall['$query'];
-            $fetch?: EdenCall['$fetch'];
-        }>) => Promise<Route['response'] extends {
-            200: infer ReturnedType;
-        } ? ReturnedType | MapError<Route['response']> : unknown> : key extends 'subscribe' ? [
-            Server[Full][key],
-            Server[Full][key]['query']
-        ] extends [
-            infer Route extends TypedRoute,
-            infer Query extends TypedRoute['query']
-        ] ? unknown extends NonNullable<Query> ? (params?: {
-            $query?: EdenCall['$query'];
-        }) => EdenWS<Route> : Query extends NonNullable<Query> ? (params: {
-            $query: Query;
-        }) => EdenWS<Route> : (params?: {
-            $query?: EdenCall['$query'];
-        }) => EdenWS<Route> : never : never;
-    } : never;
-} & (Path extends `:${infer params}` ? Record<`$${params}`, `Expected path parameters ':${params}', replace this with any string`> : {});
-declare type CamelCase<S extends string> = S extends `${infer P1}-${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : Lowercase<S>;
-export interface EdenWSOnMessage<Data = unknown> extends MessageEvent {
-    data: Data;
-    rawData: MessageEvent['data'];
-}
-export declare type EdenWSEvent<K extends keyof WebSocketEventMap, Data = unknown> = K extends 'message' ? EdenWSOnMessage<Data> : WebSocketEventMap[K];
-export interface EdenConfig {
-    fn?: string;
-    fetch?: Omit<RequestInit, 'body'>;
-}
-declare type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc['length']]>;
-declare type Range<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
-declare type ErrorRange = Range<300, 599>;
-declare type MapError<T extends Record<number, unknown>> = [
+import type { EdenFetchError } from './utils';
+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 unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+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;
+    };
+};
 export {};

package/dist/utils-0d2b8b1a.mjs

@@ -0,0 +1,8 @@
+class e extends Error {
+  constructor(r, s) {
+    super(), this.status = r, this.value = s;
+  }
+}
+export {
+  e as E
+};

package/dist/utils-0d7d9b21.js

@@ -0,0 +1 @@
+"use strict";class t extends Error{constructor(r,s){super(),this.status=r,this.value=s}}exports.EdenFetchError=t;

package/dist/utils.d.ts

@@ -1,19 +1,5 @@
-import type { EdenCall, EdenConfig } from './types';
 export declare class EdenFetchError<Status extends number = number, Value = unknown> extends Error {
     status: Status;
     value: Value;
     constructor(status: Status, value: Value);
 }
-export declare const composePath: (domain: string, path: string, query: EdenCall['$query'] | undefined) => string;
-export declare class Signal {
-    private url;
-    private config;
-    private pendings;
-    private operation;
-    private isFetching;
-    private sJson;
-    constructor(url: string, config: EdenConfig);
-    setConfig(config: EdenConfig): void;
-    clone(config?: EdenConfig): Signal;
-    run(procedure: string[], params: any): Promise<any>;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elysiajs/eden",
-  "version": "0.3.0-exp-230223.1133",
+  "version": "0.3.0-rc.0",
   "description": "Fully type-safe Elysia client",
   "author": {
     "name": "saltyAom",
@@ -14,6 +14,24 @@
       "import": "./dist/index.mjs",
       "node": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./treaty": {
+      "require": "./dist/treaty.js",
+      "import": "./dist/treaty.mjs",
+      "node": "./dist/treaty.js",
+      "default": "./dist/treaty.js"
+    },
+    "./fetch": {
+      "require": "./dist/fetch.js",
+      "import": "./dist/fetch.mjs",
+      "node": "./dist/fetch.js",
+      "default": "./dist/fetch.js"
+    },
+    "./fn": {
+      "require": "./dist/fn.js",
+      "import": "./dist/fn.mjs",
+      "node": "./dist/fn.js",
+      "default": "./dist/fn.js"
     }
   },
   "types": "./src/index.ts",
@@ -36,16 +54,21 @@
     "release": "npm run build && npm run test && npm publish --access public"
   },
   "peerDependencies": {
-    "elysia": ">= 0.3.0-exp-230222.2123"
+    "@sinclair/typebox": ">= 0.25.21",
+    "elysia": ">= 0.3.0-rc.1"
+  },
+  "peerDependenciesMeta": {
+    "@sinclair/typebox": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@elysiajs/cors": "^0.1.0",
-    "@elysiajs/websocket": "^0.2.6",
     "@sinclair/typebox": "^0.25.21",
     "@types/node": "^18.11.7",
-    "bun-types": "^0.5.0",
+    "bun-types": "^0.5.7",
+    "elysia": "0.3.0-rc.2",
     "eslint": "^8.26.0",
-    "elysia": "../elysia",
     "rimraf": "^3.0.2",
     "typescript": "^4.8.4",
     "vite": "^4.0.1",
@@ -54,4 +77,4 @@
   "dependencies": {
     "superjson": "^1.12.2"
   }
-}
+}

package/src/fetch/index.ts

@@ -0,0 +1,55 @@
+import type { Elysia } from 'elysia'
+
+import { EdenFetchError } from '../utils'
+import type { EdenFetch } from './types'
+export type { EdenFetch } from './types'
+
+export const edenFetch =
+    <App extends Elysia<any>>(
+        server: string,
+        config?: EdenFetch.Config
+    ): EdenFetch.Create<App> =>
+    // @ts-ignore
+    async (endpoint: string, { params, body, ...options } = {}) => {
+        if (params)
+            Object.entries(params).forEach(([key, value]) => {
+                endpoint = endpoint.replace(`:${key}`, value)
+            })
+
+        const contentType = options.headers?.['Content-Type']
+
+        if (!contentType || contentType === 'application/json')
+            body = JSON.stringify(body)
+
+        // @ts-ignore
+        return fetch(server + endpoint, {
+            ...options,
+            headers: {
+                'content-type': 'application/json',
+                ...options.headers
+            },
+            body
+        }).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
+        })
+    }

package/src/fetch/types.ts

@@ -0,0 +1,53 @@
+import type { Elysia, SCHEMA } from 'elysia'
+import type { EdenFetchError } from '../utils'
+import type { MapError, IsUnknown, IsNever, AnyTypedRoute } from '../types'
+
+export namespace EdenFetch {
+    export type Create<App extends Elysia<any>> = App['meta'] extends Record<
+        typeof SCHEMA,
+        infer Schema extends Record<string, any>
+    >
+        ? EdenFetch.Fn<Schema>
+        : 'Please install Elysia before using Eden'
+
+    export interface Config {}
+
+    export type Fn<Schema extends Record<string, any>> = <
+        Endpoint extends keyof Schema,
+        Method extends Extract<keyof Schema[Endpoint], string>,
+        Route extends Schema[Endpoint][Method]
+    >(
+        endpoint: Endpoint,
+        options: Omit<RequestInit, 'body' | 'method' | 'headers'> &
+            ('get' extends Method
+                ? {
+                      method?: Uppercase<Method>
+                  }
+                : {
+                      method: Uppercase<Method>
+                  }) &
+            (IsNever<keyof Route['params']> extends true
+                ? {
+                      params?: Record<never, string>
+                  }
+                : {
+                      params: Route['params']
+                  }) &
+            (undefined extends Route['headers']
+                ? {
+                      headers?: Record<string, string>
+                  }
+                : {
+                      headers: Route['headers']
+                  }) &
+            (IsUnknown<Route['body']> extends false
+                ? { body: Route['body'] }
+                : { body?: unknown })
+    ) =>
+        | Promise<Route['response']['200']>
+        | (MapError<Route['response']> extends infer Errors
+              ? IsNever<Errors> extends true
+                  ? EdenFetchError<number, string>
+                  : Errors
+              : never)
+}

package/src/fn/index.ts

@@ -0,0 +1,53 @@
+import type { Elysia } from 'elysia'
+
+import { Signal } from './utils'
+
+import type { EdenFn } from './types'
+export type { EdenFn } from './types'
+
+const createProxy = (
+    domain: string,
+    procedures: string[],
+    signal: Signal
+): Record<string, unknown> =>
+    new Proxy((..._: any[]) => {}, {
+        get(target, key, value) {
+            return createProxy(domain, [...procedures, key as string], signal)
+        },
+        apply(target, _, params) {
+            const param = params[0]
+            const procedure = procedures[0]
+
+            if (procedures.length === 1) {
+                if (
+                    procedure in Object.prototype ||
+                    procedure in Promise.prototype
+                )
+                    return target(...params)
+
+                switch (procedure) {
+                    case 'toJSON':
+                        return target(...params)
+
+                    case '$set':
+                        return signal.setConfig(param)
+
+                    case '$clone':
+                        return createProxy(domain, [], signal.clone(param))
+                }
+            }
+
+            return signal.run(procedures, params).then((result) => {
+                if (result instanceof Error) throw result
+
+                return result
+            })
+        }
+    }) as any
+
+export const edenFn = <App extends Elysia<any>>(
+    domain: string,
+    config?: EdenFn.Config
+): EdenFn.Create<App> =>
+    // @ts-ignore
+    createProxy(domain, [], new Signal(domain, config))

package/src/fn/types.ts

@@ -0,0 +1,45 @@
+import type { Elysia, EXPOSED } from 'elysia'
+
+export namespace EdenFn {
+    export type Create<App extends Elysia<any>> = App['meta'] extends Record<
+        typeof EXPOSED,
+        infer Schema extends Record<string, any>
+    >
+        ? EdenFn.Compose<Schema>
+        : 'Please install Elysia before using Eden'
+
+    export interface Config {}
+
+    export type Compose<Exposed extends Record<string, any>> = Fn<Exposed> & {
+        $set(config: Config): void
+        $clone(config?: Config): Compose<Exposed>
+    }
+
+    export type Fn<T> = T extends {
+        [EXPOSED]: any
+        value: infer Value
+    }
+        ? Asynctify<Value>
+        : Asynctify<T>
+
+    export interface Config {
+        fn?: string
+        fetch?: Omit<RequestInit, 'body'>
+    }
+}
+
+type Promisify<T extends (...args: any[]) => any> = T extends (
+    ...args: infer Args
+) => infer Return
+    ? Return extends Promise<any>
+        ? T
+        : (...args: Args) => Promise<Return>
+    : never
+
+type Asynctify<T> = T extends infer Fn extends (...args: any) => any
+    ? Promisify<Fn>
+    : T extends Record<string, any>
+    ? {
+          [K in keyof T]: EdenFn.Fn<T[K]>
+      }
+    : never

package/src/fn/utils.ts

@@ -0,0 +1,86 @@
+import type { serialize, deserialize } from 'superjson'
+import type { EdenFn } from './types'
+
+export class Signal {
+    private url: string
+    private config: EdenFn.Config
+
+    private pendings: Array<{ n: string[] } | { n: string[]; p: any }> = []
+    private operation: Promise<any[]> | null = null
+    private isFetching = false
+
+    private sJson: Promise<{
+        serialize: typeof serialize
+        deserialize: typeof deserialize
+    }>
+
+    constructor(url: string, config: EdenFn.Config = {}) {
+        this.url = url
+        this.config = config
+
+        this.sJson = import('superjson').then((superJson) => {
+            return {
+                serialize: superJson.serialize,
+                deserialize: superJson.deserialize
+            }
+        })
+    }
+
+    setConfig(config: EdenFn.Config) {
+        this.config = config
+    }
+
+    clone(config?: EdenFn.Config) {
+        return new Signal(this.url, config ?? this.config)
+    }
+
+    async run(procedure: string[], params: any) {
+        const current = +this.pendings.length
+        this.pendings.push(
+            params !== undefined
+                ? { n: procedure, p: params }
+                : { n: procedure }
+        )
+
+        if (this.isFetching) return this.operation?.then((x) => x[current])
+        this.isFetching = true
+
+        this.operation = new Promise((resolve) => {
+            setTimeout(async () => {
+                const requests = [...this.pendings]
+                this.pendings = []
+
+                const { serialize, deserialize } = await this.sJson
+
+                const results = await fetch(
+                    `${this.url}${this.config.fn ?? '/~fn'}`,
+                    {
+                        method: 'POST',
+                        ...this.config.fetch,
+                        headers: {
+                            'content-type': 'elysia/fn',
+                            ...this.config.fetch?.headers
+                        },
+                        body: JSON.stringify(serialize(requests))
+                    }
+                )
+
+                if (results.status === 200)
+                    resolve(results.json().then((x) => deserialize(x as any)))
+                else
+                    resolve(
+                        Array(requests.length).fill(
+                            new Error(await results.text())
+                        )
+                    )
+            }, 33)
+        })
+
+        const result = await this.operation.then((results) => results[current])
+
+        this.operation = null
+        this.isFetching = false
+
+        return result
+    }
+}