nuxt-surrealdb
Version:
A Nuxt module aimed to simplify the use of SurrealDB
319 lines (273 loc) • 9.91 kB
text/typescript
import * as _nuxt_schema from '@nuxt/schema';
import { PublicRuntimeConfig, RuntimeConfig } from '@nuxt/schema';
import { FetchError, FetchRequest as FetchRequest$1, FetchOptions, ResponseType } from 'ofetch';
import { AsyncDataOptions as AsyncDataOptions$1 } from 'nuxt/app';
import { Ref, WatchSource, ComputedRef } from 'vue';
import { AsyncDataOptions, AsyncData } from '#app';
import { Overrides as Overrides$1 } from '#surrealdb/types/index';
/**
* The following is a custom implementation of Nuxt's useFetch composable.
* It is meant to be used in a Nuxt project when connecting to third-party APIs,
* while using a custom $fetch loaded as a Nuxt plugin.
*
* Source:
* https://gist.github.com/sandros94/9105defd5f02d2614372da6d53023822
*/
type MultiWatchSources = (WatchSource<unknown> | object)[];
type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : K[number] extends never ? T : Pick<T, K[number]> : T;
type KeysOf$1<T> = Array<T extends T ? keyof T extends string ? keyof T : never : never>;
type FetchRequest = Exclude<FetchRequest$1, string> | (string & {});
type _AvailableMethods = 'get' | 'post' | 'patch' | 'delete' | 'search';
type AvailableMethods = _AvailableMethods | Uppercase<_AvailableMethods>;
type ComputedOptions<T extends Record<string, any>> = {
[K in keyof T]: T[K] extends Function ? T[K] : ComputedOptions<T[K]> | Ref<T[K]> | T[K];
};
interface CustomFetchOptions<M extends AvailableMethods = AvailableMethods> extends FetchOptions, Overrides$1 {
method?: M;
}
interface UseSurrealFetchOptions<ResT, DataT = ResT, DefaultT = undefined, PickKeys extends KeysOf$1<DataT> = KeysOf$1<DataT>, M extends AvailableMethods = AvailableMethods> extends Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'watch'>, ComputedOptions<CustomFetchOptions<M>> {
key?: string;
$fetch?: typeof globalThis.$fetch;
watch?: MultiWatchSources | false;
}
/**
* Fetch data from an API endpoint with an SSR-friendly composable.
* @param request The URL to fetch
* @param opts extends $surrealFetch options and useAsyncData options
*/
declare function useSurrealFetch<ResT = void, DataT = ResT, DefaultT = undefined, PickKeys extends KeysOf$1<DataT> = KeysOf$1<DataT>, ErrorT = FetchError, ReqT extends FetchRequest = FetchRequest, Method extends AvailableMethods = AvailableMethods>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseSurrealFetchOptions<ResT, DataT, DefaultT, PickKeys, Method>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>;
declare function useSurrealFetch<ResT = void, DataT = ResT, DefaultT = DataT, PickKeys extends KeysOf$1<DataT> = KeysOf$1<DataT>, ErrorT = FetchError, ReqT extends FetchRequest = FetchRequest, Method extends AvailableMethods = AvailableMethods>(request: Ref<ReqT> | ReqT | (() => ReqT), opts?: UseSurrealFetchOptions<ResT, DataT, DefaultT, PickKeys, Method>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, ErrorT | undefined>;
interface User {}
interface UserSession {
user?: User
}
interface UserSessionRequired extends UserSession {
user: User
}
interface UserSessionComposable {
loggedIn: ComputedRef<boolean>
user: ComputedRef<User | null>
session: Ref<UserSession>
fetch: () => Promise<void>
clear: () => Promise<void>
}
/* Database Overrides */
type DatabasePresetKeys = keyof PublicRuntimeConfig['surrealdb']['databases']
type DatabasePresetServerKeys =
keyof PublicRuntimeConfig['surrealdb']['databases']
& keyof RuntimeConfig['surrealdb']['databases']
type AuthToken = string | {
user: string
pass: string
}
interface Overrides {
database?: DatabasePresetKeys | DatabasePreset
token?: AuthToken | boolean
}
interface ServerOverrides {
database?: DatabasePresetServerKeys | DatabasePreset
token?: AuthToken | boolean
}
interface DatabasePreset {
host?: string
ws?: string
NS?: string
DB?: string
SC?: string
AC?: string
auth?: AuthToken
}
/* useAsyncData and useFetch custom options */
type SurrealAsyncDataOptions<T, R = T> = AsyncDataOptions$1<T, R> & Overrides & {
key?: string
}
type SurrealFetchOptions<
T extends ResponseType = 'json',
> = Omit<FetchOptions<T>, 'method'> & {
method?: Uppercase<SurrealMethods> | SurrealMethods
}
type UseSurrealRpcOptions<
ResT,
DataT = ResT,
DefaultT = undefined,
PickKeys extends KeysOf<DataT> = KeysOf<DataT>,
> = Omit<UseSurrealFetchOptions<ResT, DataT, DefaultT, PickKeys>, 'method' | 'body' | 'onResponse'>
/* Utils */
type JSONPatchPath<T> = T extends object ? {
[K in keyof T]-?: K extends string ? `/${K}` | `/${K}${Path<T[K]>}` : never
}[keyof T] : ''
type JSONPatchValue<T, P extends string> = P extends `${infer K}/${infer Rest}`
? K extends keyof T
? Rest extends JSONPatchPath<T[K]>
? JSONPatchValue<T[K], Rest>
: T[K]
: never
: P extends keyof T
? T[P]
: never
type JSONPatch<T> = {
op: 'add' | 'remove' | 'replace' | 'copy' | 'move' | 'test'
from?: JSONPatchPath<T>
path: JSONPatchPath<T>
value?: JSONPatchValue<T, JSONPatchPath<T>>
}
type SurrealMethods = 'get' | 'post' | 'put' | 'patch' | 'delete'
/* SurrealDB RPC Methods and Params types */
type CreateParams<T> = [
thing: string,
data?: Partial<T>,
]
type InsertParams<T> = [
thing: string,
data?: Partial<T>,
]
type MergeParams<T> = [
thing: string,
data: Partial<T>,
]
type PatchParams<T> = [
thing: string,
patches: JSONPatch<T>[],
diff?: boolean,
]
type QueryParams = [
sql: string,
vars?: Record<string, any>,
]
// TODO: Check if it is possible to not use Record<string, string | undefined>
type SignInParams = [Record<string, string | undefined>]
type SignUpParams = [{
NS: string
DB: string
[key: string]: string
}]
type UpdateParams<T> = [
thing: string,
data?: Partial<T>,
]
interface RpcMethods<T> {
authenticate: [string]
create: CreateParams<T>
delete: [string]
info: never
insert: InsertParams<T>
invalidate: never
merge: MergeParams<T>
patch: PatchParams<T>
query: QueryParams
select: [string]
signin: SignInParams
signup: SignUpParams
update: UpdateParams<T>
}
interface RpcMethodsWS<T> extends RpcMethods<T> {
kill: [string]
let: [
name: string,
value: any,
]
live: [
table: string,
diff?: Partial<T>,
]
unset: [string]
use: [
NS?: string,
DB?: string,
]
}
type RpcParams<T, M extends keyof RpcMethods<T>> = RpcMethods<T>[M]
type RpcParamsWS<T, M extends keyof RpcMethodsWS<T>> = RpcMethodsWS<T>[M]
/* SurrealDB RPC Request and Response types */
interface RpcRequest<
T = any,
M extends keyof RpcMethods<T> = keyof RpcMethods<T>,
P extends RpcParams<T, M> = RpcParams<T, M>,
> {
method: M
params?: P
}
interface RpcRequestWS<
T = any,
M extends keyof RpcMethodsWS<T> = keyof RpcMethodsWS<T>,
P extends RpcParamsWS<T, M> = RpcParamsWS<T, M>,
> {
method: M
params?: P
}
interface RpcResponseOk<R> {
result: R
error: never
}
interface RpcResponseOkWS<R> {
id: number
result: R
error: never
}
interface RpcResponseError {
result: never
error: {
code: number
message: string
}
}
interface RpcResponseErrorWS {
id: number
result: never
error: {
code: number
message: string
}
}
type RpcResponse<R> = RpcResponseOk<R> | RpcResponseError
type RpcResponseWS<R> = RpcResponseOkWS<R> | RpcResponseErrorWS
/* SurrealDB HTTP Response types */
interface HttpResponseOk<R> {
result: R
status: 'OK'
time: string
}
interface HttpResponseError {
result: string
status: 'ERR'
time: string
}
type HttpResponse<R> = Array<(HttpResponseOk<R> | HttpResponseError)>
type HttpRes<R> = HttpResponse<R>
/* Utility Types */
type QueryResponse<T> = T extends [infer First, ...infer Rest]
? [RpcResponse<First>, ...QueryResponse<Rest>]
: RpcResponse<any>[]
type PublicDatabases = PublicRuntimeConfig['surrealdb']['databases'];
interface ModuleOptions {
auth: {
adminMaxAge?: number;
database?: keyof PublicDatabases | false;
sessionName?: string;
cookieName?: string;
sameSite?: boolean | 'strict' | 'lax' | 'none';
};
databases: {
default?: DatabasePreset;
[key: string]: DatabasePreset | undefined;
};
server: {
databases?: {
[key: string]: DatabasePreset | undefined;
};
};
}
declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
interface SurrealServerOptions {
surrealdb?: ModuleOptions['server'];
}
interface SurrealOptions {
surrealdb?: Omit<ModuleOptions, 'server'>;
}
declare module '@nuxt/schema' {
interface RuntimeConfig extends SurrealServerOptions {
}
interface PublicRuntimeConfig extends SurrealOptions {
}
}
export { type AuthToken, type ComputedOptions, type DatabasePreset, type DatabasePresetKeys, type DatabasePresetServerKeys, type HttpRes, type HttpResponse, type HttpResponseError, type HttpResponseOk, type JSONPatch, type JSONPatchPath, type JSONPatchValue, type KeysOf$1 as KeysOf, type ModuleOptions, type Overrides, type PickFrom, type QueryResponse, type RpcMethods, type RpcMethodsWS, type RpcParams, type RpcParamsWS, type RpcRequest, type RpcRequestWS, type RpcResponse, type RpcResponseError, type RpcResponseErrorWS, type RpcResponseOk, type RpcResponseOkWS, type RpcResponseWS, type ServerOverrides, type SurrealAsyncDataOptions, type SurrealFetchOptions, type SurrealMethods, type UseSurrealFetchOptions, type UseSurrealRpcOptions, type User, type UserSession, type UserSessionComposable, type UserSessionRequired, _default as default, useSurrealFetch };