@feathersjs/feathers

constructor

constructor();

property appHooks

appHooks: HookMap<Application<Services, Settings>, any>;

property mixins

mixins: ServiceMixin<Application<Services, Settings>>[];

property services

services: {};

property settings

settings: {};

property version

version: string;

method configure

configure: (callback: (this: this, app: this) => void) => this;

method defaultService

defaultService: (location: string) => ServiceInterface;

method get

get: <L extends keyof Settings & string>(name: L) => Settings[L];

method hooks

hooks: (hookMap: ApplicationHookOptions<this>) => this;

method service

service: <L extends keyof Services & string>(
    location: L
) => FeathersService<
    this,
    keyof any extends keyof Services ? Service : Services[L]
>;

method set

set: <L extends keyof Settings & string>(name: L, value: Settings[L]) => this;

method setup

setup: () => Promise<this>;

method teardown

teardown: () => Promise<this>;

method use

use: <L extends keyof Services & string>(
    path: L,
    service: keyof any extends keyof Services
        ? ServiceInterface | Application
        : Services[L],
    options?: ServiceOptions
) => this;

constructor

constructor(app: {}, method: string);

property app

app: {};

property method

method: string;

method collectMiddleware

collectMiddleware: (self: any, args: any[]) => Middleware[];

method initializeContext

initializeContext: (self: any, args: any[], context: HookContext) => any;

method middleware

middleware: (mw: Middleware[]) => this;

property app

app: A;

property server

server: any;

property appHooks

appHooks: HookMap<Application<Services, Settings>, any>;

• Contains all registered application level hooks.

property mixins

mixins: ServiceMixin<Application<Services, Settings>>[];

• A list of callbacks that run when a new service is registered

property services

services: Services;

• The index of all services keyed by their path.

  __Important:__ Services should always be retrieved via app.service('name') not via app.services.

property settings

settings: Settings;

• The application settings that can be used via app.get and app.set

property version

version: string;

• The Feathers application version

method configure

configure: (callback: (this: this, app: this) => void) => this;

• Runs a callback configure function with the current application instance.

  Parameter callback

  The callback (app: Application) => {} to run

method defaultService

defaultService: (location: string) => ServiceInterface;

• Returns a fallback service instance that will be registered when no service was found. Usually throws a NotFound error but also used to instantiate client side services.

  Parameter location

  The path of the service

method get

get: <L extends keyof Settings & string>(name: L) => Settings[L];

• Retrieve an application setting by name

  Parameter name

  The setting name

method hooks

hooks: (map: ApplicationHookOptions<this>) => this;

• Register application level hooks.

  Parameter map

  The application hook settings.

method service

service: <L extends keyof Services & string>(
    path: L
) => FeathersService<
    this,
    keyof any extends keyof Services ? Service : Services[L]
>;

• Get the Feathers service instance for a path. This will be the service originally registered with Feathers functionality like hooks and events added.

  Parameter path

  The name of the service.

method set

set: <L extends keyof Settings & string>(name: L, value: Settings[L]) => this;

• Set an application setting

  Parameter name

  The setting name

  Parameter value

  The setting value

method setup

setup: (server?: any) => Promise<this>;

• Set up the application and call all services .setup method if available.

  Parameter server

  A server instance (optional)

method teardown

teardown: (server?: any) => Promise<this>;

• Tear down the application and call all services .teardown method if available.

  Parameter server

  A server instance (optional)

method use

use: <L extends keyof Services & string>(
    path: L,
    service: keyof any extends keyof Services
        ? ServiceInterface | Application
        : Services[L],
    options?: ServiceOptions
) => this;

• Register a new service or a sub-app. When passed another Feathers application, all its services will be re-registered with the path prefix.

  Parameter path

  The path for the service to register

  Parameter service

  The service object to register or another Feathers application to use a sub-app under the path prefix.

  Parameter options

  The options for this service

property app

readonly app: A;

• A read only property that contains the Feathers application object. This can be used to retrieve other services (via context.app.service('name')) or configuration values.

property arguments

readonly arguments: any[];

• The list of method arguments. Should not be modified, modify the params, data and id properties instead.

property data

data?: ServiceGenericData<S>;

• A writeable property containing the data of a create, update and patch service method call.

property dispatch

dispatch?: ServiceGenericType<S>;

• A writeable, optional property and contains a 'safe' version of the data that should be sent to any client. If context.dispatch has not been set context.result will be sent to the client instead.

property error

error?: any;

• A writeable property with the error object that was thrown in a failed method call. It is only available in error hooks.

property event

event: string | null;

• The event emitted by this method. Can be set to null to skip event emitting.

property http

http?: Http;

• A writeable, optional property with options specific to HTTP transports.

property id

id?: Id;

• A writeable property and the id for a get, remove, update and patch service method call. For remove, update and patch context.id can also be null when modifying multiple entries. In all other cases it will be undefined.

property method

readonly method: string;

• A read only property with the name of the service method (one of find, get, create, update, patch, remove).

property params

params: ServiceGenericParams<S>;

• A writeable property that contains the service method parameters (including params.query).

property path

readonly path: string;

• A read only property and contains the service name (or path) without leading or trailing slashes.

property result

result?: ServiceGenericType<S>;

• A writeable property containing the result of the successful service method call. It is only available in after hooks.

  context.result can also be set in

  - A before hook to skip the actual service method (database) call - An error hook to swallow the error and return a result instead

property service

readonly service: S;

• A read only property and contains the service this hook currently runs on.

property statusCode

statusCode?: number;

• A writeable, optional property that allows to override the standard HTTP status code that should be returned.

  Deprecated

  Use http.status instead.

property type

readonly type: null | 'before' | 'after' | 'error';

• A read only property with the hook type (one of before, after or error). Will be null for asynchronous hooks.

property headers

headers?: { [key: string]: string | string[] };

• A writeable, optional property with headers.

property location

location?: string;

• A writeable, optional property with Location header's value.

property status

status?: number;

• A writeable, optional property with status code override.

property data

data: T[];

property limit

limit: number;

property skip

skip: number;

property total

total: number;

property headers

headers?: { [key: string]: any };

property provider

provider?: string;

property query

query?: Q;

property route

route?: { [key: string]: any };

index signature

[key: string]: any;

property id

id?: string;

method hooks

hooks: (options: HookOptions<A, S>) => this;

method create

create: (
    data: ServiceGenericData<S> | ServiceGenericData<S>[],
    params: P,
    context: HookContext
) => Promise<HookContext>;

method find

find: (params: P, context: HookContext) => Promise<HookContext>;

method get

get: (id: Id, params: P, context: HookContext) => Promise<HookContext>;

method patch

patch: (
    id: NullableId,
    data: ServiceGenericData<S>,
    params: P,
    context: HookContext
) => Promise<HookContext>;

method remove

remove: (
    id: NullableId,
    params: P,
    context: HookContext
) => Promise<HookContext>;

method update

update: (
    id: NullableId,
    data: ServiceGenericData<S>,
    params: P,
    context: HookContext
) => Promise<HookContext>;

method create

create: (data: D, params?: P) => Promise<T>;

method find

find: (params?: P) => Promise<T | T[]>;

method get

get: (id: Id, params?: P) => Promise<T>;

method patch

patch: (id: NullableId, data: D, params?: P) => Promise<T | T[]>;

method remove

remove: (id: NullableId, params?: P) => Promise<T | T[]>;

method setup

setup: (app: Application, path: string) => Promise<void>;

method teardown

teardown: (app: Application, path: string) => Promise<void>;

method update

update: (id: NullableId, data: D, params?: P) => Promise<T | T[]>;

property events

events?: string[];

property methods

methods?: string[];

property routeParams

routeParams?: { [key: string]: any };

property serviceEvents

serviceEvents?: string[];

method create

create: (data: D[], params?: P) => Promise<T[]>;

method patch

patch: {
    (id: Id, data: D, params?: P): Promise<T>;
    (id: null, data: D, params?: P): Promise<T[]>;
};

method remove

remove: {
    (id: Id, params?: P): Promise<T>;
    (id: null, params?: P): Promise<T[]>;
};

method update

update: {
    (id: Id, data: D, params?: P): Promise<T>;
    (id: null, data: D, params?: P): Promise<T[]>;
};