spiceflow 1.1.8 → 1.1.10

package/src/client/types.ts

@@ -6,7 +6,7 @@ import { EdenFetchError } from './errors.js'
 import { EdenWS } from './ws.js'
 
 export type Prettify<T> = {
-	[K in keyof T]: T[K]
+  [K in keyof T]: T[K]
 } & {}
 
 export type IsNever<T> = [T] extends [never] ? true : false
@@ -14,208 +14,185 @@ export type IsNever<T> = [T] extends [never] ? true : false
 type Files = File | FileList
 
 type ReplaceBlobWithFiles<in out RecordType extends Record<string, unknown>> = {
-	[K in keyof RecordType]: RecordType[K] extends Blob | Blob[]
-		? Files
-		: RecordType[K]
+  [K in keyof RecordType]: RecordType[K] extends Blob | Blob[]
+    ? Files
+    : RecordType[K]
 } & {}
 
 type And<A extends boolean, B extends boolean> = A extends true
-	? B extends true
-		? true
-		: false
-	: false
+  ? B extends true
+    ? true
+    : false
+  : false
 
 type ReplaceGeneratorWithAsyncGenerator<
-	in out RecordType extends Record<string, unknown>,
+  in out RecordType extends Record<string, unknown>,
 > = {
-	[K in keyof RecordType]: RecordType[K] extends Generator<
-		infer A,
-		infer B,
-		infer C
-	>
-		? And<Not<IsNever<A>>, void extends B ? true : false> extends true
-			? AsyncGenerator<A, B, C>
-			: And<IsNever<A>, void extends B ? false : true> extends true
-			? B
-			: AsyncGenerator<A, B, C> | B
-		: RecordType[K] extends AsyncGenerator<infer A, infer B, infer C>
-		? And<Not<IsNever<A>>, void extends B ? true : false> extends true
-			? AsyncGenerator<A, B, C>
-			: And<IsNever<A>, void extends B ? false : true> extends true
-			? B
-			: AsyncGenerator<A, B, C> | B
-		: RecordType[K]
+  [K in keyof RecordType]: RecordType[K] extends Generator<
+    infer A,
+    infer B,
+    infer C
+  >
+    ? And<Not<IsNever<A>>, void extends B ? true : false> extends true
+      ? AsyncGenerator<A, B, C>
+      : And<IsNever<A>, void extends B ? false : true> extends true
+        ? B
+        : AsyncGenerator<A, B, C> | B
+    : RecordType[K] extends AsyncGenerator<infer A, infer B, infer C>
+      ? And<Not<IsNever<A>>, void extends B ? true : false> extends true
+        ? AsyncGenerator<A, B, C>
+        : And<IsNever<A>, void extends B ? false : true> extends true
+          ? B
+          : AsyncGenerator<A, B, C> | B
+      : RecordType[K]
 } & {}
 
 type MaybeArray<T> = T | T[]
 type MaybePromise<T> = T | Promise<T>
 
 export namespace SpiceflowClient {
-	interface TreatyParam {
-		fetch?: RequestInit
-	}
-
-	export type Create<App extends Spiceflow<any, any, any, any, any, any>> =
-		App extends {
-			_routes: infer Schema extends Record<string, any>
-		}
-			? Prettify<Sign<Schema>>
-			: 'Please install Spiceflow before using Eden'
-
-	export type Sign<in out Route extends Record<string, any>> = {
-		[K in keyof Route as K extends `:${string}`
-			? never
-			: K]: K extends 'subscribe' // ? Websocket route
-			? (undefined extends Route['subscribe']['headers']
-					? { headers?: Record<string, unknown> }
-					: {
-							headers: Route['subscribe']['headers']
-					  }) &
-					(undefined extends Route['subscribe']['query']
-						? { query?: Record<string, unknown> }
-						: {
-								query: Route['subscribe']['query']
-						  }) extends infer Param
-				? {} extends Param
-					? (options?: Param) => EdenWS<Route['subscribe']>
-					: (options?: Param) => EdenWS<Route['subscribe']>
-				: never
-			: Route[K] extends {
-					body: infer Body
-					// headers: infer Headers
-					params: any
-					query: infer Query
-					response: infer Response extends Record<number, unknown>
-			  }
-			? { headers?: Record<string, unknown> } & (undefined extends Query
-					? { query?: Record<string, unknown> }
-					: { query: Query }) extends infer Param
-				? {} extends Param
-					? undefined extends Body
-						? K extends 'get' | 'head'
-							? (
-									options?: Prettify<Param & TreatyParam>,
-							  ) => Promise<
-									TreatyResponse<
-										ReplaceGeneratorWithAsyncGenerator<Response>
-									>
-							  >
-							: (
-									body?: Body,
-									options?: Prettify<Param & TreatyParam>,
-							  ) => Promise<
-									TreatyResponse<
-										ReplaceGeneratorWithAsyncGenerator<Response>
-									>
-							  >
-						: (
-								body: Body extends Record<string, unknown>
-									? ReplaceBlobWithFiles<Body>
-									: Body,
-								options?: Prettify<Param & TreatyParam>,
-						  ) => Promise<
-								TreatyResponse<
-									ReplaceGeneratorWithAsyncGenerator<Response>
-								>
-						  >
-					: K extends 'get' | 'head'
-					? (
-							options: Prettify<Param & TreatyParam>,
-					  ) => Promise<
-							TreatyResponse<
-								ReplaceGeneratorWithAsyncGenerator<Response>
-							>
-					  >
-					: (
-							body: Body extends Record<string, unknown>
-								? ReplaceBlobWithFiles<Body>
-								: Body,
-							options: Prettify<Param & TreatyParam>,
-					  ) => Promise<
-							TreatyResponse<
-								ReplaceGeneratorWithAsyncGenerator<Response>
-							>
-					  >
-				: never
-			: 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>>
-			: // ! DO NOT USE PRETTIFY ON THIS LINE, OTHERWISE FUNCTION CALLING WILL BE OMITTED
-			  (((params: {
-					[param in Path extends `:${infer Param}`
-						? Param extends `${infer Param}?`
-							? Param
-							: Param
-						: never]: string | number
-			  }) => Prettify<Sign<Route[Path]>> & CreateParams<Route[Path]>) &
-					Prettify<Sign<Route>>) &
-					(Path extends `:${string}?`
-						? CreateParams<Route[Path]>
-						: {})
-		: never
-
-	export interface Config {
-		// fetch?: Omit<RequestInit, 'headers' | 'method'>
-		fetch?: typeof fetch
-		headers?: MaybeArray<
-			| RequestInit['headers']
-			| ((
-					path: string,
-					options: RequestInit,
-			  ) => RequestInit['headers'] | void)
-		>
-		onRequest?: MaybeArray<
-			(
-				path: string,
-				options: RequestInit,
-			) => MaybePromise<RequestInit | void>
-		>
-		onResponse?: MaybeArray<(response: Response) => MaybePromise<unknown>>
-		// keepDomain?: boolean
-	}
-
-	// type UnwrapAwaited<T extends Record<number, unknown>> = {
-	//     [K in keyof T]: Awaited<T[K]>
-	// }
-
-	export type TreatyResponse<Res extends Record<number, unknown>> =
-		| {
-				data: Res[200]
-				error: null
-				response: Response
-				status: number
-				headers: RequestInit['headers']
-		  }
-		| {
-				data: null
-				error: Exclude<keyof Res, 200> extends never
-					? EdenFetchError<number, any>
-					: {
-							[Status in keyof Res]: EdenFetchError<
-								Status,
-								Res[Status]
-							>
-					  }[Exclude<keyof Res, 200>]
-				response: Response
-				status: number
-				headers: RequestInit['headers']
-		  }
-
-	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]
+  interface TreatyParam {
+    fetch?: RequestInit
+  }
+
+  export type Create<App extends Spiceflow<any, any, any, any, any, any>> =
+    App extends {
+      _routes: infer Schema extends Record<string, any>
+    }
+      ? Prettify<Sign<Schema>>
+      : 'Please install Spiceflow before using Eden'
+
+  export type Sign<in out Route extends Record<string, any>> = {
+    [K in keyof Route as K extends `:${string}`
+      ? never
+      : K]: K extends 'subscribe' // ? Websocket route
+      ? (undefined extends Route['subscribe']['headers']
+          ? { headers?: Record<string, unknown> }
+          : {
+              headers: Route['subscribe']['headers']
+            }) &
+          (undefined extends Route['subscribe']['query']
+            ? { query?: Record<string, unknown> }
+            : {
+                query: Route['subscribe']['query']
+              }) extends infer Param
+        ? {} extends Param
+          ? (options?: Param) => EdenWS<Route['subscribe']>
+          : (options?: Param) => EdenWS<Route['subscribe']>
+        : never
+      : Route[K] extends {
+            body: infer Body
+            // headers: infer Headers
+            params: any
+            query: infer Query
+            response: infer Response extends Record<number, unknown>
+          }
+        ? { headers?: Record<string, unknown> } & (undefined extends Query
+            ? { query?: Record<string, unknown> }
+            : { query: Query }) extends infer Param
+          ? {} extends Param
+            ? undefined extends Body
+              ? K extends 'get' | 'head'
+                ? (
+                    options?: Prettify<Param & TreatyParam>,
+                  ) => Promise<
+                    TreatyResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
+                  >
+                : (
+                    body?: Body,
+                    options?: Prettify<Param & TreatyParam>,
+                  ) => Promise<
+                    TreatyResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
+                  >
+              : (
+                  body: Body extends Record<string, unknown>
+                    ? ReplaceBlobWithFiles<Body>
+                    : Body,
+                  options?: Prettify<Param & TreatyParam>,
+                ) => Promise<
+                  TreatyResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
+                >
+            : K extends 'get' | 'head'
+              ? (
+                  options: Prettify<Param & TreatyParam>,
+                ) => Promise<
+                  TreatyResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
+                >
+              : (
+                  body: Body extends Record<string, unknown>
+                    ? ReplaceBlobWithFiles<Body>
+                    : Body,
+                  options: Prettify<Param & TreatyParam>,
+                ) => Promise<
+                  TreatyResponse<ReplaceGeneratorWithAsyncGenerator<Response>>
+                >
+          : never
+        : 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>>
+        : // ! DO NOT USE PRETTIFY ON THIS LINE, OTHERWISE FUNCTION CALLING WILL BE OMITTED
+          (((params: {
+            [param in Path extends `:${infer Param}`
+              ? Param extends `${infer Param}?`
+                ? Param
+                : Param
+              : never]: string | number
+          }) => Prettify<Sign<Route[Path]>> & CreateParams<Route[Path]>) &
+            Prettify<Sign<Route>>) &
+            (Path extends `:${string}?` ? CreateParams<Route[Path]> : {})
+      : never
+
+  export interface Config {
+    // fetch?: Omit<RequestInit, 'headers' | 'method'>
+    fetch?: typeof fetch
+    headers?: MaybeArray<
+      | RequestInit['headers']
+      | ((path: string, options: RequestInit) => RequestInit['headers'] | void)
+    >
+    onRequest?: MaybeArray<
+      (path: string, options: RequestInit) => MaybePromise<RequestInit | void>
+    >
+    onResponse?: MaybeArray<(response: Response) => MaybePromise<unknown>>
+    // keepDomain?: boolean
+  }
+
+  // type UnwrapAwaited<T extends Record<number, unknown>> = {
+  //     [K in keyof T]: Awaited<T[K]>
+  // }
+
+  export type TreatyResponse<Res extends Record<number, unknown>> =
+    | {
+        data: Res[200]
+        error: null
+        response: Response
+        status: number
+        headers: RequestInit['headers']
+      }
+    | {
+        data: null
+        error: Exclude<keyof Res, 200> extends never
+          ? EdenFetchError<number, any>
+          : {
+              [Status in keyof Res]: EdenFetchError<Status, Res[Status]>
+            }[Exclude<keyof Res, 200>]
+        response: Response
+        status: number
+        headers: RequestInit['headers']
+      }
+
+  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 type Not<T> = T extends true ? false : true

package/src/client/utils.ts

@@ -1,7 +1,7 @@
 export function parseStringifiedValue(value: string) {
-	try {
-		return JSON.parse(value)
-	} catch (error) {
-		return value
-	}
+  try {
+    return JSON.parse(value)
+  } catch (error) {
+    return value
+  }
 }

package/src/client/ws.ts

@@ -3,97 +3,95 @@ import type { SpiceflowClient } from './types.js'
 import { parseStringifiedValue } from './utils.js'
 
 export class EdenWS<in out Schema extends InputSchema<any> = {}> {
-	ws: WebSocket
-
-	constructor(public url: string) {
-		this.ws = new WebSocket(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: SpiceflowClient.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: SpiceflowClient.WSEvent<'message', Schema['response']>
-		) => void,
-		options?: boolean | AddEventListenerOptions
-	) {
-		return this.addEventListener('message', onMessage, options)
-	}
-
-	addEventListener<K extends keyof WebSocketEventMap>(
-		type: K,
-		listener: (event: SpiceflowClient.WSEvent<K, Schema['response']>) => void,
-		options?: boolean | AddEventListenerOptions
-	) {
-		this.ws.addEventListener(
-			type,
-			(ws) => {
-				if (type === 'message') {
-					const data = parseMessageEvent(ws as MessageEvent)
-
-					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
-	}
+  ws: WebSocket
+
+  constructor(public url: string) {
+    this.ws = new WebSocket(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: SpiceflowClient.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: SpiceflowClient.WSEvent<'message', Schema['response']>,
+    ) => void,
+    options?: boolean | AddEventListenerOptions,
+  ) {
+    return this.addEventListener('message', onMessage, options)
+  }
+
+  addEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (event: SpiceflowClient.WSEvent<K, Schema['response']>) => void,
+    options?: boolean | AddEventListenerOptions,
+  ) {
+    this.ws.addEventListener(
+      type,
+      (ws) => {
+        if (type === 'message') {
+          const data = parseMessageEvent(ws as MessageEvent)
+
+          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 parseMessageEvent = (event: MessageEvent) => {
-	const messageString = event.data.toString()
+  const messageString = event.data.toString()
 
-	return messageString === 'null'
-		? null
-		: parseStringifiedValue(messageString)
+  return messageString === 'null' ? null : parseStringifiedValue(messageString)
 }