1146 lines
38 KiB
TypeScript
1146 lines
38 KiB
TypeScript
interface SerializeOptions {
|
|
encode?: (val: string | number | boolean) => string;
|
|
maxAge?: number;
|
|
domain?: string;
|
|
path?: string;
|
|
expires?: Date;
|
|
httpOnly?: boolean;
|
|
secure?: boolean;
|
|
priority?: string;
|
|
sameSite?: boolean | string;
|
|
}
|
|
declare abstract class BaseModel {
|
|
[key: string]: any;
|
|
id: string;
|
|
created: string;
|
|
updated: string;
|
|
constructor(data?: {
|
|
[key: string]: any;
|
|
});
|
|
/**
|
|
* Alias of this.$load(data).
|
|
*/
|
|
load(data: {
|
|
[key: string]: any;
|
|
}): void;
|
|
/**
|
|
* Loads `data` into the current model.
|
|
*/
|
|
$load(data: {
|
|
[key: string]: any;
|
|
}): void;
|
|
/**
|
|
* Returns whether the current loaded data represent a stored db record.
|
|
*/
|
|
get $isNew(): boolean;
|
|
/**
|
|
* Alias of this.clone().
|
|
*/
|
|
clone(): BaseModel;
|
|
/**
|
|
* Creates a deep clone of the current model.
|
|
*/
|
|
$clone(): BaseModel;
|
|
/**
|
|
* Alias of this.$export().
|
|
*/
|
|
export(): {
|
|
[key: string]: any;
|
|
};
|
|
/**
|
|
* Exports all model properties as a new plain object.
|
|
*/
|
|
$export(): {
|
|
[key: string]: any;
|
|
};
|
|
}
|
|
declare class Record extends BaseModel {
|
|
collectionId: string;
|
|
collectionName: string;
|
|
expand: {
|
|
[key: string]: Record | Array<Record>;
|
|
};
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
$load(data: {
|
|
[key: string]: any;
|
|
}): void;
|
|
/**
|
|
* Loads the provided expand items and recursively normalizes each
|
|
* item to a `Record|Array<Record>`.
|
|
*/
|
|
private _loadExpand;
|
|
}
|
|
declare class Admin extends BaseModel {
|
|
avatar: number;
|
|
email: string;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
$load(data: {
|
|
[key: string]: any;
|
|
}): void;
|
|
}
|
|
type OnStoreChangeFunc = (token: string, model: Record | Admin | null) => void;
|
|
/**
|
|
* Base AuthStore class that is intended to be extended by all other
|
|
* PocketBase AuthStore implementations.
|
|
*/
|
|
declare abstract class BaseAuthStore {
|
|
protected baseToken: string;
|
|
protected baseModel: Record | Admin | null;
|
|
private _onChangeCallbacks;
|
|
/**
|
|
* Retrieves the stored token (if any).
|
|
*/
|
|
get token(): string;
|
|
/**
|
|
* Retrieves the stored model data (if any).
|
|
*/
|
|
get model(): Record | Admin | null;
|
|
/**
|
|
* Loosely checks if the store has valid token (aka. existing and unexpired exp claim).
|
|
*/
|
|
get isValid(): boolean;
|
|
/**
|
|
* Saves the provided new token and model data in the auth store.
|
|
*/
|
|
save(token: string, model: Record | Admin | null): void;
|
|
/**
|
|
* Removes the stored token and model data form the auth store.
|
|
*/
|
|
clear(): void;
|
|
/**
|
|
* Parses the provided cookie string and updates the store state
|
|
* with the cookie's token and model data.
|
|
*
|
|
* NB! This function doesn't validate the token or its data.
|
|
* Usually this isn't a concern if you are interacting only with the
|
|
* PocketBase API because it has the proper server-side security checks in place,
|
|
* but if you are using the store `isValid` state for permission controls
|
|
* in a node server (eg. SSR), then it is recommended to call `authRefresh()`
|
|
* after loading the cookie to ensure an up-to-date token and model state.
|
|
* For example:
|
|
*
|
|
* ```js
|
|
* pb.authStore.loadFromCookie("cookie string...");
|
|
*
|
|
* try {
|
|
* // get an up-to-date auth store state by veryfing and refreshing the loaded auth model (if any)
|
|
* pb.authStore.isValid && await pb.collection('users').authRefresh();
|
|
* } catch (_) {
|
|
* // clear the auth store on failed refresh
|
|
* pb.authStore.clear();
|
|
* }
|
|
* ```
|
|
*/
|
|
loadFromCookie(cookie: string, key?: string): void;
|
|
/**
|
|
* Exports the current store state as cookie string.
|
|
*
|
|
* By default the following optional attributes are added:
|
|
* - Secure
|
|
* - HttpOnly
|
|
* - SameSite=Strict
|
|
* - Path=/
|
|
* - Expires={the token expiration date}
|
|
*
|
|
* NB! If the generated cookie exceeds 4096 bytes, this method will
|
|
* strip the model data to the bare minimum to try to fit within the
|
|
* recommended size in https://www.rfc-editor.org/rfc/rfc6265#section-6.1.
|
|
*/
|
|
exportToCookie(options?: SerializeOptions, key?: string): string;
|
|
/**
|
|
* Register a callback function that will be called on store change.
|
|
*
|
|
* You can set the `fireImmediately` argument to true in order to invoke
|
|
* the provided callback right after registration.
|
|
*
|
|
* Returns a removal function that you could call to "unsubscribe" from the changes.
|
|
*/
|
|
onChange(callback: OnStoreChangeFunc, fireImmediately?: boolean): () => void;
|
|
protected triggerChange(): void;
|
|
}
|
|
/**
|
|
* BaseService class that should be inherited from all API services.
|
|
*/
|
|
declare abstract class BaseService {
|
|
readonly client: Client;
|
|
constructor(client: Client);
|
|
}
|
|
interface BaseQueryParams {
|
|
[key: string]: any;
|
|
fields?: string;
|
|
$autoCancel?: boolean;
|
|
$cancelKey?: string;
|
|
}
|
|
interface ListQueryParams extends BaseQueryParams {
|
|
page?: number;
|
|
perPage?: number;
|
|
sort?: string;
|
|
filter?: string;
|
|
}
|
|
interface FullListQueryParams extends ListQueryParams {
|
|
batch?: number;
|
|
}
|
|
interface RecordQueryParams extends BaseQueryParams {
|
|
expand?: string;
|
|
}
|
|
interface RecordListQueryParams extends ListQueryParams, RecordQueryParams {
|
|
}
|
|
interface RecordFullListQueryParams extends FullListQueryParams, RecordQueryParams {
|
|
}
|
|
interface LogStatsQueryParams extends BaseQueryParams {
|
|
filter?: string;
|
|
}
|
|
interface FileQueryParams extends BaseQueryParams {
|
|
thumb?: string;
|
|
}
|
|
interface appleClientSecret {
|
|
secret: string;
|
|
}
|
|
declare class SettingsService extends BaseService {
|
|
/**
|
|
* Fetch all available app settings.
|
|
*/
|
|
getAll(queryParams?: BaseQueryParams): Promise<{
|
|
[key: string]: any;
|
|
}>;
|
|
/**
|
|
* Bulk updates app settings.
|
|
*/
|
|
update(bodyParams?: {}, queryParams?: BaseQueryParams): Promise<{
|
|
[key: string]: any;
|
|
}>;
|
|
/**
|
|
* Performs a S3 filesystem connection test.
|
|
*
|
|
* The currently supported `filesystem` are "storage" and "backups".
|
|
*/
|
|
testS3(filesystem?: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Sends a test email.
|
|
*
|
|
* The possible `emailTemplate` values are:
|
|
* - verification
|
|
* - password-reset
|
|
* - email-change
|
|
*/
|
|
testEmail(toEmail: string, emailTemplate: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Generates a new Apple OAuth2 client secret.
|
|
*/
|
|
generateAppleClientSecret(clientId: string, teamId: string, keyId: string, privateKey: string, duration: number, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<appleClientSecret>;
|
|
}
|
|
declare class ListResult<M = BaseModel> {
|
|
page: number;
|
|
perPage: number;
|
|
totalItems: number;
|
|
totalPages: number;
|
|
items: Array<M>;
|
|
constructor(page: number, perPage: number, totalItems: number, totalPages: number, items: Array<M>);
|
|
}
|
|
// @todo since there is no longer need of SubCrudService consider merging with CrudService in v0.9+
|
|
declare abstract class BaseCrudService<M extends BaseModel> extends BaseService {
|
|
/**
|
|
* Response data decoder.
|
|
*/
|
|
abstract decode(data: {
|
|
[key: string]: any;
|
|
}): M;
|
|
/**
|
|
* Returns a promise with all list items batch fetched at once.
|
|
*/
|
|
protected _getFullList<T = M>(basePath: string, batchSize?: number, queryParams?: ListQueryParams): Promise<Array<T>>;
|
|
/**
|
|
* Returns paginated items list.
|
|
*/
|
|
protected _getList<T = M>(basePath: string, page?: number, perPage?: number, queryParams?: ListQueryParams): Promise<ListResult<T>>;
|
|
/**
|
|
* Returns single item by its id.
|
|
*/
|
|
protected _getOne<T = M>(basePath: string, id: string, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* Returns the first found item by a list filter.
|
|
*
|
|
* Internally it calls `_getList(basePath, 1, 1, { filter })` and returns its
|
|
* first item.
|
|
*
|
|
* For consistency with `_getOne`, this method will throw a 404
|
|
* ClientResponseError if no item was found.
|
|
*/
|
|
protected _getFirstListItem<T = M>(basePath: string, filter: string, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* Creates a new item.
|
|
*/
|
|
protected _create<T = M>(basePath: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* Updates an existing item by its id.
|
|
*/
|
|
protected _update<T = M>(basePath: string, id: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* Deletes an existing item by its id.
|
|
*/
|
|
protected _delete(basePath: string, id: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
}
|
|
declare abstract class CrudService<M extends BaseModel> extends BaseCrudService<M> {
|
|
/**
|
|
* Base path for the crud actions (without trailing slash, eg. '/admins').
|
|
*/
|
|
abstract get baseCrudPath(): string;
|
|
/**
|
|
* Returns a promise with all list items batch fetched at once
|
|
* (by default 200 items per request; to change it set the `batch` query param).
|
|
*
|
|
* You can use the generic T to supply a wrapper type of the crud model.
|
|
*/
|
|
getFullList<T = M>(queryParams?: FullListQueryParams): Promise<Array<T>>;
|
|
/**
|
|
* Legacy version of getFullList with explicitly specified batch size.
|
|
*/
|
|
getFullList<T = M>(batch?: number, queryParams?: ListQueryParams): Promise<Array<T>>;
|
|
/**
|
|
* Returns paginated items list.
|
|
*
|
|
* You can use the generic T to supply a wrapper type of the crud model.
|
|
*/
|
|
getList<T = M>(page?: number, perPage?: number, queryParams?: ListQueryParams): Promise<ListResult<T>>;
|
|
/**
|
|
* Returns the first found item by the specified filter.
|
|
*
|
|
* Internally it calls `getList(1, 1, { filter })` and returns the
|
|
* first found item.
|
|
*
|
|
* You can use the generic T to supply a wrapper type of the crud model.
|
|
*
|
|
* For consistency with `getOne`, this method will throw a 404
|
|
* ClientResponseError if no item was found.
|
|
*/
|
|
getFirstListItem<T = M>(filter: string, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* Returns single item by its id.
|
|
*
|
|
* You can use the generic T to supply a wrapper type of the crud model.
|
|
*/
|
|
getOne<T = M>(id: string, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* Creates a new item.
|
|
*
|
|
* You can use the generic T to supply a wrapper type of the crud model.
|
|
*/
|
|
create<T = M>(bodyParams?: {}, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* Updates an existing item by its id.
|
|
*
|
|
* You can use the generic T to supply a wrapper type of the crud model.
|
|
*/
|
|
update<T = M>(id: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* Deletes an existing item by its id.
|
|
*/
|
|
delete(id: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
}
|
|
interface AdminAuthResponse {
|
|
[key: string]: any;
|
|
token: string;
|
|
admin: Admin;
|
|
}
|
|
declare class AdminService extends CrudService<Admin> {
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
decode(data: {
|
|
[key: string]: any;
|
|
}): Admin;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
get baseCrudPath(): string;
|
|
// ---------------------------------------------------------------
|
|
// Post update/delete AuthStore sync
|
|
// ---------------------------------------------------------------
|
|
/**
|
|
* @inheritdoc
|
|
*
|
|
* If the current `client.authStore.model` matches with the updated id, then
|
|
* on success the `client.authStore.model` will be updated with the result.
|
|
*/
|
|
update<T = Admin>(id: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<T>;
|
|
/**
|
|
* @inheritdoc
|
|
*
|
|
* If the current `client.authStore.model` matches with the deleted id,
|
|
* then on success the `client.authStore` will be cleared.
|
|
*/
|
|
delete(id: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
// ---------------------------------------------------------------
|
|
// Auth handlers
|
|
// ---------------------------------------------------------------
|
|
/**
|
|
* Prepare successful authorize response.
|
|
*/
|
|
protected authResponse(responseData: any): AdminAuthResponse;
|
|
/**
|
|
* Authenticate an admin account with its email and password
|
|
* and returns a new admin token and data.
|
|
*
|
|
* On success this method automatically updates the client's AuthStore data.
|
|
*/
|
|
authWithPassword(email: string, password: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<AdminAuthResponse>;
|
|
/**
|
|
* Refreshes the current admin authenticated instance and
|
|
* returns a new token and admin data.
|
|
*
|
|
* On success this method automatically updates the client's AuthStore data.
|
|
*/
|
|
authRefresh(bodyParams?: {}, queryParams?: BaseQueryParams): Promise<AdminAuthResponse>;
|
|
/**
|
|
* Sends admin password reset request.
|
|
*/
|
|
requestPasswordReset(email: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Confirms admin password reset request.
|
|
*/
|
|
confirmPasswordReset(passwordResetToken: string, password: string, passwordConfirm: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
}
|
|
declare class ExternalAuth extends BaseModel {
|
|
recordId: string;
|
|
collectionId: string;
|
|
provider: string;
|
|
providerId: string;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
$load(data: {
|
|
[key: string]: any;
|
|
}): void;
|
|
}
|
|
type UnsubscribeFunc = () => Promise<void>;
|
|
declare class RealtimeService extends BaseService {
|
|
clientId: string;
|
|
private eventSource;
|
|
private subscriptions;
|
|
private lastSentTopics;
|
|
private connectTimeoutId;
|
|
private maxConnectTimeout;
|
|
private reconnectTimeoutId;
|
|
private reconnectAttempts;
|
|
private maxReconnectAttempts;
|
|
private predefinedReconnectIntervals;
|
|
private pendingConnects;
|
|
/**
|
|
* Returns whether the realtime connection has been established.
|
|
*/
|
|
get isConnected(): boolean;
|
|
/**
|
|
* Register the subscription listener.
|
|
*
|
|
* You can subscribe multiple times to the same topic.
|
|
*
|
|
* If the SSE connection is not started yet,
|
|
* this method will also initialize it.
|
|
*/
|
|
subscribe(topic: string, callback: (data: any) => void): Promise<UnsubscribeFunc>;
|
|
/**
|
|
* Unsubscribe from all subscription listeners with the specified topic.
|
|
*
|
|
* If `topic` is not provided, then this method will unsubscribe
|
|
* from all active subscriptions.
|
|
*
|
|
* This method is no-op if there are no active subscriptions.
|
|
*
|
|
* The related sse connection will be autoclosed if after the
|
|
* unsubscribe operation there are no active subscriptions left.
|
|
*/
|
|
unsubscribe(topic?: string): Promise<void>;
|
|
/**
|
|
* Unsubscribe from all subscription listeners starting with the specified topic prefix.
|
|
*
|
|
* This method is no-op if there are no active subscriptions with the specified topic prefix.
|
|
*
|
|
* The related sse connection will be autoclosed if after the
|
|
* unsubscribe operation there are no active subscriptions left.
|
|
*/
|
|
unsubscribeByPrefix(topicPrefix: string): Promise<void>;
|
|
/**
|
|
* Unsubscribe from all subscriptions matching the specified topic and listener function.
|
|
*
|
|
* This method is no-op if there are no active subscription with
|
|
* the specified topic and listener.
|
|
*
|
|
* The related sse connection will be autoclosed if after the
|
|
* unsubscribe operation there are no active subscriptions left.
|
|
*/
|
|
unsubscribeByTopicAndListener(topic: string, listener: EventListener): Promise<void>;
|
|
private hasSubscriptionListeners;
|
|
private submitSubscriptions;
|
|
private getSubscriptionsCancelKey;
|
|
private getNonEmptySubscriptionTopics;
|
|
private addAllSubscriptionListeners;
|
|
private removeAllSubscriptionListeners;
|
|
private connect;
|
|
private initConnect;
|
|
private hasUnsentSubscriptions;
|
|
private connectErrorHandler;
|
|
private disconnect;
|
|
}
|
|
interface RecordAuthResponse<T = Record> {
|
|
record: T;
|
|
token: string;
|
|
meta?: {
|
|
[key: string]: any;
|
|
};
|
|
}
|
|
interface AuthProviderInfo {
|
|
name: string;
|
|
state: string;
|
|
codeVerifier: string;
|
|
codeChallenge: string;
|
|
codeChallengeMethod: string;
|
|
authUrl: string;
|
|
}
|
|
interface AuthMethodsList {
|
|
usernamePassword: boolean;
|
|
emailPassword: boolean;
|
|
authProviders: Array<AuthProviderInfo>;
|
|
}
|
|
interface RecordSubscription<T = Record> {
|
|
action: string; // eg. create, update, delete
|
|
record: T;
|
|
}
|
|
type OAuth2UrlCallback = (url: string) => void | Promise<void>;
|
|
interface OAuth2AuthConfig {
|
|
// the name of the OAuth2 provider (eg. "google")
|
|
provider: string;
|
|
// custom scopes to overwrite the default ones
|
|
scopes?: Array<string>;
|
|
// optional record create data
|
|
createData?: {
|
|
[key: string]: any;
|
|
};
|
|
// optional callback that is triggered after the OAuth2 sign-in/sign-up url generation
|
|
urlCallback?: OAuth2UrlCallback;
|
|
// optional query params to send with the PocketBase auth request (eg. fields, expand, etc.)
|
|
query?: RecordQueryParams;
|
|
// optional body params to send with the PocketBase auth request
|
|
body?: {
|
|
[key: string]: any;
|
|
};
|
|
}
|
|
declare class RecordService extends CrudService<Record> {
|
|
readonly collectionIdOrName: string;
|
|
constructor(client: Client, collectionIdOrName: string);
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
decode<T = Record>(data: {
|
|
[key: string]: any;
|
|
}): T;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
get baseCrudPath(): string;
|
|
/**
|
|
* Returns the current collection service base path.
|
|
*/
|
|
get baseCollectionPath(): string;
|
|
// ---------------------------------------------------------------
|
|
// Realtime handlers
|
|
// ---------------------------------------------------------------
|
|
/**
|
|
* @deprecated Use subscribe(recordId, callback) instead.
|
|
*
|
|
* Subscribe to the realtime changes of a single record in the collection.
|
|
*/
|
|
subscribeOne<T = Record>(recordId: string, callback: (data: RecordSubscription<T>) => void): Promise<UnsubscribeFunc>;
|
|
/**
|
|
* @deprecated This form of subscribe is deprecated. Please use `subscribe("*", callback)`.
|
|
*/
|
|
subscribe<T = Record>(callback: (data: RecordSubscription<T>) => void): Promise<UnsubscribeFunc>;
|
|
/**
|
|
* Subscribe to realtime changes to the specified topic ("*" or record id).
|
|
*
|
|
* If `topic` is the wildcard "*", then this method will subscribe to
|
|
* any record changes in the collection.
|
|
*
|
|
* If `topic` is a record id, then this method will subscribe only
|
|
* to changes of the specified record id.
|
|
*
|
|
* It's OK to subscribe multiple times to the same topic.
|
|
* You can use the returned `UnsubscribeFunc` to remove only a single subscription.
|
|
* Or use `unsubscribe(topic)` if you want to remove all subscriptions attached to the topic.
|
|
*/
|
|
subscribe<T = Record>(topic: string, callback: (data: RecordSubscription<T>) => void): Promise<UnsubscribeFunc>;
|
|
/**
|
|
* Unsubscribe from all subscriptions of the specified topic
|
|
* ("*" or record id).
|
|
*
|
|
* If `topic` is not set, then this method will unsubscribe from
|
|
* all subscriptions associated to the current collection.
|
|
*/
|
|
unsubscribe(topic?: string): Promise<void>;
|
|
// ---------------------------------------------------------------
|
|
// Crud handers
|
|
// ---------------------------------------------------------------
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
getFullList<T = Record>(queryParams?: RecordFullListQueryParams): Promise<Array<T>>;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
getFullList<T = Record>(batch?: number, queryParams?: RecordListQueryParams): Promise<Array<T>>;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
getList<T = Record>(page?: number, perPage?: number, queryParams?: RecordListQueryParams): Promise<ListResult<T>>;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
getFirstListItem<T = Record>(filter: string, queryParams?: RecordListQueryParams): Promise<T>;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
getOne<T = Record>(id: string, queryParams?: RecordQueryParams): Promise<T>;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
create<T = Record>(bodyParams?: {}, queryParams?: RecordQueryParams): Promise<T>;
|
|
/**
|
|
* @inheritdoc
|
|
*
|
|
* If the current `client.authStore.model` matches with the updated id, then
|
|
* on success the `client.authStore.model` will be updated with the result.
|
|
*/
|
|
update<T = Record>(id: string, bodyParams?: {}, queryParams?: RecordQueryParams): Promise<T>;
|
|
/**
|
|
* @inheritdoc
|
|
*
|
|
* If the current `client.authStore.model` matches with the deleted id,
|
|
* then on success the `client.authStore` will be cleared.
|
|
*/
|
|
delete(id: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
// ---------------------------------------------------------------
|
|
// Auth handlers
|
|
// ---------------------------------------------------------------
|
|
/**
|
|
* Prepare successful collection authorization response.
|
|
*/
|
|
protected authResponse<T = Record>(responseData: any): RecordAuthResponse<T>;
|
|
/**
|
|
* Returns all available collection auth methods.
|
|
*/
|
|
listAuthMethods(queryParams?: BaseQueryParams): Promise<AuthMethodsList>;
|
|
/**
|
|
* Authenticate a single auth collection record via its username/email and password.
|
|
*
|
|
* On success, this method also automatically updates
|
|
* the client's AuthStore data and returns:
|
|
* - the authentication token
|
|
* - the authenticated record model
|
|
*/
|
|
authWithPassword<T = Record>(usernameOrEmail: string, password: string, bodyParams?: {}, queryParams?: RecordQueryParams): Promise<RecordAuthResponse<T>>;
|
|
/**
|
|
* Authenticate a single auth collection record with OAuth2 code.
|
|
*
|
|
* If you don't have an OAuth2 code you may also want to check `authWithOAuth2` method.
|
|
*
|
|
* On success, this method also automatically updates
|
|
* the client's AuthStore data and returns:
|
|
* - the authentication token
|
|
* - the authenticated record model
|
|
* - the OAuth2 account data (eg. name, email, avatar, etc.)
|
|
*/
|
|
authWithOAuth2Code<T = Record>(provider: string, code: string, codeVerifier: string, redirectUrl: string, createData?: {}, bodyParams?: {}, queryParams?: RecordQueryParams): Promise<RecordAuthResponse<T>>;
|
|
/**
|
|
* @deprecated This form of authWithOAuth2 is deprecated.
|
|
*
|
|
* Please use `authWithOAuth2Code()` OR its simplified realtime version
|
|
* as shown in https://pocketbase.io/docs/authentication/#oauth2-integration.
|
|
*/
|
|
authWithOAuth2<T = Record>(provider: string, code: string, codeVerifier: string, redirectUrl: string, createData?: {
|
|
[key: string]: any;
|
|
}, bodyParams?: {
|
|
[key: string]: any;
|
|
}, queryParams?: RecordQueryParams): Promise<RecordAuthResponse<T>>;
|
|
/**
|
|
* Authenticate a single auth collection record with OAuth2
|
|
* **without custom redirects, deeplinks or even page reload**.
|
|
*
|
|
* This method initializes a one-off realtime subscription and will
|
|
* open a popup window with the OAuth2 vendor page to authenticate.
|
|
* Once the external OAuth2 sign-in/sign-up flow is completed, the popup
|
|
* window will be automatically closed and the OAuth2 data sent back
|
|
* to the user through the previously established realtime connection.
|
|
*
|
|
* You can specify an optional `urlCallback` prop to customize
|
|
* the default url `window.open` behavior.
|
|
*
|
|
* On success, this method also automatically updates
|
|
* the client's AuthStore data and returns:
|
|
* - the authentication token
|
|
* - the authenticated record model
|
|
* - the OAuth2 account data (eg. name, email, avatar, etc.)
|
|
*
|
|
* Example:
|
|
*
|
|
* ```js
|
|
* const authData = await pb.collection("users").authWithOAuth2({
|
|
* provider: "google",
|
|
* })
|
|
* ```
|
|
*
|
|
* _Site-note_: when creating the OAuth2 app in the provider dashboard
|
|
* you have to configure `https://yourdomain.com/api/oauth2-redirect`
|
|
* as redirect URL.
|
|
*/
|
|
authWithOAuth2<T = Record>(options: OAuth2AuthConfig): Promise<RecordAuthResponse<T>>;
|
|
/**
|
|
* Refreshes the current authenticated record instance and
|
|
* returns a new token and record data.
|
|
*
|
|
* On success this method also automatically updates the client's AuthStore.
|
|
*/
|
|
authRefresh<T = Record>(bodyParams?: {}, queryParams?: RecordQueryParams): Promise<RecordAuthResponse<T>>;
|
|
/**
|
|
* Sends auth record password reset request.
|
|
*/
|
|
requestPasswordReset(email: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Confirms auth record password reset request.
|
|
*/
|
|
confirmPasswordReset(passwordResetToken: string, password: string, passwordConfirm: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Sends auth record verification email request.
|
|
*/
|
|
requestVerification(email: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Confirms auth record email verification request.
|
|
*/
|
|
confirmVerification(verificationToken: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Sends an email change request to the authenticated record model.
|
|
*/
|
|
requestEmailChange(newEmail: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Confirms auth record's new email address.
|
|
*/
|
|
confirmEmailChange(emailChangeToken: string, password: string, bodyParams?: {}, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Lists all linked external auth providers for the specified auth record.
|
|
*/
|
|
listExternalAuths(recordId: string, queryParams?: BaseQueryParams): Promise<Array<ExternalAuth>>;
|
|
/**
|
|
* Unlink a single external auth provider from the specified auth record.
|
|
*/
|
|
unlinkExternalAuth(recordId: string, provider: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
// ---------------------------------------------------------------
|
|
// very rudimentary url query params replacement because at the moment
|
|
// URL (and URLSearchParams) doesn't seem to be fully supported in React Native
|
|
//
|
|
// note: for details behind some of the decode/encode parsing check https://unixpapa.com/js/querystring.html
|
|
private _replaceQueryParams;
|
|
private _defaultUrlCallback;
|
|
}
|
|
declare class SchemaField {
|
|
id: string;
|
|
name: string;
|
|
type: string;
|
|
system: boolean;
|
|
required: boolean;
|
|
options: {
|
|
[key: string]: any;
|
|
};
|
|
constructor(data?: {
|
|
[key: string]: any;
|
|
});
|
|
}
|
|
declare class Collection extends BaseModel {
|
|
name: string;
|
|
type: string;
|
|
schema: Array<SchemaField>;
|
|
indexes: Array<string>;
|
|
system: boolean;
|
|
listRule: null | string;
|
|
viewRule: null | string;
|
|
createRule: null | string;
|
|
updateRule: null | string;
|
|
deleteRule: null | string;
|
|
options: {
|
|
[key: string]: any;
|
|
};
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
$load(data: {
|
|
[key: string]: any;
|
|
}): void;
|
|
/**
|
|
* @deprecated Please use $isBase instead.
|
|
*/
|
|
get isBase(): boolean;
|
|
/**
|
|
* Checks if the current model is "base" collection.
|
|
*/
|
|
get $isBase(): boolean;
|
|
/**
|
|
* @deprecated Please use $isAuth instead.
|
|
*/
|
|
get isAuth(): boolean;
|
|
/**
|
|
* Checks if the current model is "auth" collection.
|
|
*/
|
|
get $isAuth(): boolean;
|
|
/**
|
|
* @deprecated Please use $isView instead.
|
|
*/
|
|
get isView(): boolean;
|
|
/**
|
|
* Checks if the current model is "view" collection.
|
|
*/
|
|
get $isView(): boolean;
|
|
}
|
|
declare class CollectionService extends CrudService<Collection> {
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
decode(data: {
|
|
[key: string]: any;
|
|
}): Collection;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
get baseCrudPath(): string;
|
|
/**
|
|
* Imports the provided collections.
|
|
*
|
|
* If `deleteMissing` is `true`, all local collections and schema fields,
|
|
* that are not present in the imported configuration, WILL BE DELETED
|
|
* (including their related records data)!
|
|
*/
|
|
import(collections: Array<Collection>, deleteMissing?: boolean, queryParams?: BaseQueryParams): Promise<true>;
|
|
}
|
|
declare class LogRequest extends BaseModel {
|
|
url: string;
|
|
method: string;
|
|
status: number;
|
|
auth: string;
|
|
remoteIp: string;
|
|
userIp: string;
|
|
referer: string;
|
|
userAgent: string;
|
|
meta: {
|
|
[key: string]: any;
|
|
};
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
$load(data: {
|
|
[key: string]: any;
|
|
}): void;
|
|
}
|
|
interface HourlyStats {
|
|
total: number;
|
|
date: string;
|
|
}
|
|
declare class LogService extends BaseService {
|
|
/**
|
|
* Returns paginated logged requests list.
|
|
*/
|
|
getRequestsList(page?: number, perPage?: number, queryParams?: ListQueryParams): Promise<ListResult<LogRequest>>;
|
|
/**
|
|
* Returns a single logged request by its id.
|
|
*/
|
|
getRequest(id: string, queryParams?: BaseQueryParams): Promise<LogRequest>;
|
|
/**
|
|
* Returns request logs statistics.
|
|
*/
|
|
getRequestsStats(queryParams?: LogStatsQueryParams): Promise<Array<HourlyStats>>;
|
|
}
|
|
interface HealthCheckResponse {
|
|
code: number;
|
|
message: string;
|
|
data: {
|
|
[key: string]: any;
|
|
};
|
|
}
|
|
declare class HealthService extends BaseService {
|
|
/**
|
|
* Checks the health status of the api.
|
|
*/
|
|
check(queryParams?: BaseQueryParams): Promise<HealthCheckResponse>;
|
|
}
|
|
declare class FileService extends BaseService {
|
|
/**
|
|
* Builds and returns an absolute record file url for the provided filename.
|
|
*/
|
|
getUrl(record: Pick<Record, "id" | "collectionId" | "collectionName">, filename: string, queryParams?: FileQueryParams): string;
|
|
/**
|
|
* Requests a new private file access token for the current auth model (admin or record).
|
|
*/
|
|
getToken(queryParams?: BaseQueryParams): Promise<string>;
|
|
}
|
|
interface BackupFileInfo {
|
|
key: string;
|
|
size: number;
|
|
modified: string;
|
|
}
|
|
declare class BackupService extends BaseService {
|
|
/**
|
|
* Returns list with all available backup files.
|
|
*/
|
|
getFullList(queryParams?: BaseQueryParams): Promise<Array<BackupFileInfo>>;
|
|
/**
|
|
* Initializes a new backup.
|
|
*/
|
|
create(basename: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Deletes a single backup file.
|
|
*/
|
|
delete(key: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Initializes an app data restore from an existing backup.
|
|
*/
|
|
restore(key: string, queryParams?: BaseQueryParams): Promise<boolean>;
|
|
/**
|
|
* Builds a download url for a single existing backup using an
|
|
* admin file token and the backup file key.
|
|
*
|
|
* The file token can be generated via `pb.files.getToken()`.
|
|
*/
|
|
getDownloadUrl(token: string, key: string): string;
|
|
}
|
|
interface SendOptions extends RequestInit {
|
|
headers?: {
|
|
[key: string]: string;
|
|
};
|
|
body?: any;
|
|
params?: BaseQueryParams;
|
|
}
|
|
interface BeforeSendResult {
|
|
[key: string]: any; // for backward compatibility
|
|
url?: string;
|
|
options?: {
|
|
[key: string]: any;
|
|
};
|
|
}
|
|
/**
|
|
* PocketBase JS Client.
|
|
*/
|
|
declare class Client {
|
|
/**
|
|
* The base PocketBase backend url address (eg. 'http://127.0.0.1.8090').
|
|
*/
|
|
baseUrl: string;
|
|
/**
|
|
* Hook that get triggered right before sending the fetch request,
|
|
* allowing you to inspect and modify the url and request options.
|
|
*
|
|
* For list of the possible options check https://developer.mozilla.org/en-US/docs/Web/API/fetch#options
|
|
*
|
|
* You can return a non-empty result object `{ url, options }` to replace the url and request options entirely.
|
|
*
|
|
* Example:
|
|
* ```js
|
|
* client.beforeSend = function (url, options) {
|
|
* options.headers = Object.assign({}, options.headers, {
|
|
* 'X-Custom-Header': 'example',
|
|
* });
|
|
*
|
|
* return { url, options }
|
|
* };
|
|
* ```
|
|
*/
|
|
beforeSend?: (url: string, options: SendOptions) => BeforeSendResult | Promise<BeforeSendResult>;
|
|
/**
|
|
* Hook that get triggered after successfully sending the fetch request,
|
|
* allowing you to inspect/modify the response object and its parsed data.
|
|
*
|
|
* Returns the new Promise resolved `data` that will be returned to the client.
|
|
*
|
|
* Example:
|
|
* ```js
|
|
* client.afterSend = function (response, data) {
|
|
* if (response.status != 200) {
|
|
* throw new ClientResponseError({
|
|
* url: response.url,
|
|
* status: response.status,
|
|
* data: data,
|
|
* });
|
|
* }
|
|
*
|
|
* return data;
|
|
* };
|
|
* ```
|
|
*/
|
|
afterSend?: (response: Response, data: any) => any;
|
|
/**
|
|
* Optional language code (default to `en-US`) that will be sent
|
|
* with the requests to the server as `Accept-Language` header.
|
|
*/
|
|
lang: string;
|
|
/**
|
|
* A replaceable instance of the local auth store service.
|
|
*/
|
|
authStore: BaseAuthStore;
|
|
/**
|
|
* An instance of the service that handles the **Settings APIs**.
|
|
*/
|
|
readonly settings: SettingsService;
|
|
/**
|
|
* An instance of the service that handles the **Admin APIs**.
|
|
*/
|
|
readonly admins: AdminService;
|
|
/**
|
|
* An instance of the service that handles the **Collection APIs**.
|
|
*/
|
|
readonly collections: CollectionService;
|
|
/**
|
|
* An instance of the service that handles the **File APIs**.
|
|
*/
|
|
readonly files: FileService;
|
|
/**
|
|
* An instance of the service that handles the **Log APIs**.
|
|
*/
|
|
readonly logs: LogService;
|
|
/**
|
|
* An instance of the service that handles the **Realtime APIs**.
|
|
*/
|
|
readonly realtime: RealtimeService;
|
|
/**
|
|
* An instance of the service that handles the **Health APIs**.
|
|
*/
|
|
readonly health: HealthService;
|
|
/**
|
|
* An instance of the service that handles the **Backup APIs**.
|
|
*/
|
|
readonly backups: BackupService;
|
|
private cancelControllers;
|
|
private recordServices;
|
|
private enableAutoCancellation;
|
|
constructor(baseUrl?: string, authStore?: BaseAuthStore | null, lang?: string);
|
|
/**
|
|
* Returns the RecordService associated to the specified collection.
|
|
*
|
|
* @param {string} idOrName
|
|
* @return {RecordService}
|
|
*/
|
|
collection(idOrName: string): RecordService;
|
|
/**
|
|
* Globally enable or disable auto cancellation for pending duplicated requests.
|
|
*/
|
|
autoCancellation(enable: boolean): Client;
|
|
/**
|
|
* Cancels single request by its cancellation key.
|
|
*/
|
|
cancelRequest(cancelKey: string): Client;
|
|
/**
|
|
* Cancels all pending requests.
|
|
*/
|
|
cancelAllRequests(): Client;
|
|
/**
|
|
* Sends an api http request.
|
|
*/
|
|
send<T = any>(path: string, reqOptions: SendOptions): Promise<T>;
|
|
/**
|
|
* Legacy alias of `pb.files.getUrl()`.
|
|
*/
|
|
getFileUrl(record: Pick<Record, "id" | "collectionId" | "collectionName">, filename: string, queryParams?: FileQueryParams): string;
|
|
/**
|
|
* Builds a full client url by safely concatenating the provided path.
|
|
*/
|
|
buildUrl(path: string): string;
|
|
/**
|
|
* Loosely checks if the specified body is a FormData instance.
|
|
*/
|
|
private isFormData;
|
|
/**
|
|
* Serializes the provided query parameters into a query string.
|
|
*/
|
|
private serializeQueryParams;
|
|
}
|
|
/**
|
|
* ClientResponseError is a custom Error class that is intended to wrap
|
|
* and normalize any error thrown by `Client.send()`.
|
|
*/
|
|
declare class ClientResponseError extends Error {
|
|
url: string;
|
|
status: number;
|
|
response: {
|
|
[key: string]: any;
|
|
};
|
|
isAbort: boolean;
|
|
originalError: any;
|
|
constructor(errData?: any);
|
|
/**
|
|
* Alias for `this.response` to preserve the backward compatibility.
|
|
*/
|
|
get data(): {
|
|
[key: string]: any;
|
|
};
|
|
/**
|
|
* Make a POJO's copy of the current error class instance.
|
|
* @see https://github.com/vuex-orm/vuex-orm/issues/255
|
|
*/
|
|
toJSON(): this;
|
|
}
|
|
/**
|
|
* The default token store for browsers with auto fallback
|
|
* to runtime/memory if local storage is undefined (eg. in node env).
|
|
*/
|
|
declare class LocalAuthStore extends BaseAuthStore {
|
|
private storageFallback;
|
|
private storageKey;
|
|
constructor(storageKey?: string);
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
get token(): string;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
get model(): Record | Admin | null;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
save(token: string, model: Record | Admin | null): void;
|
|
/**
|
|
* @inheritdoc
|
|
*/
|
|
clear(): void;
|
|
// ---------------------------------------------------------------
|
|
// Internal helpers:
|
|
// ---------------------------------------------------------------
|
|
/**
|
|
* Retrieves `key` from the browser's local storage
|
|
* (or runtime/memory if local storage is undefined).
|
|
*/
|
|
private _storageGet;
|
|
/**
|
|
* Stores a new data in the browser's local storage
|
|
* (or runtime/memory if local storage is undefined).
|
|
*/
|
|
private _storageSet;
|
|
/**
|
|
* Removes `key` from the browser's local storage and the runtime/memory.
|
|
*/
|
|
private _storageRemove;
|
|
}
|
|
/**
|
|
* Returns JWT token's payload data.
|
|
*/
|
|
declare function getTokenPayload(token: string): {
|
|
[key: string]: any;
|
|
};
|
|
/**
|
|
* Checks whether a JWT token is expired or not.
|
|
* Tokens without `exp` payload key are considered valid.
|
|
* Tokens with empty payload (eg. invalid token strings) are considered expired.
|
|
*
|
|
* @param token The token to check.
|
|
* @param [expirationThreshold] Time in seconds that will be subtracted from the token `exp` property.
|
|
*/
|
|
declare function isTokenExpired(token: string, expirationThreshold?: number): boolean;
|
|
export { Client as default, ClientResponseError, BaseAuthStore, LocalAuthStore, getTokenPayload, isTokenExpired, ExternalAuth, Admin, Collection, Record, LogRequest, BaseModel, ListResult, SchemaField, CrudService, AdminService, CollectionService, LogService, RealtimeService, RecordService, SettingsService, HealthCheckResponse, BackupFileInfo, SendOptions, BeforeSendResult, RecordAuthResponse, AuthProviderInfo, AuthMethodsList, RecordSubscription, OAuth2UrlCallback, OAuth2AuthConfig, OnStoreChangeFunc, UnsubscribeFunc, BaseQueryParams, ListQueryParams, RecordQueryParams, RecordListQueryParams, LogStatsQueryParams, FileQueryParams, FullListQueryParams, RecordFullListQueryParams };
|