angular-in-memory-web-api

constructor

constructor(
    inMemDbService: InMemoryDbService,
    config?: InMemoryBackendConfigArgs
);

property config

protected config: InMemoryBackendConfigArgs;

property db

protected db: { [key: string]: any };

property dbReady

readonly dbReady: Observable<boolean>;

property dbReadySubject

protected dbReadySubject: any;

property inMemDbService

protected inMemDbService: InMemoryDbService;

property requestInfoUtils

protected requestInfoUtils: RequestInfoUtilities;

method addDelay

protected addDelay: (response: Observable<any>) => Observable<any>;

• Add configured delay to response observable unless delay === 0

method applyQuery

protected applyQuery: (collection: any[], query: Map<string, string[]>) => any[];

• Apply query/search parameters as a filter over the collection This impl only supports RegExp queries on string properties of the collection ANDs the conditions together

method bind

protected bind: <T extends Function>(methodName: string) => T | undefined;

• Get a method from the InMemoryDbService (if it exists), bound to that service

method bodify

protected bodify: (data: any) => any;

method clone

protected clone: (data: any) => any;

method collectionHandler

protected collectionHandler: (reqInfo: RequestInfo_2) => ResponseOptions;

method commands

protected commands: (reqInfo: RequestInfo_2) => Observable<any>;

• Commands reconfigure the in-memory web api service or extract information from it. Commands ignore the latency delay and respond ASAP.

  When the last segment of the apiBase path is "commands", the collectionName is the command.

  Example URLs: commands/resetdb (POST) // Reset the "database" to its original state commands/config (GET) // Return this service's config object commands/config (POST) // Update the config (e.g. the delay)

  Usage: http.post('commands/resetdb', undefined); http.get('commands/config'); http.post('commands/config', '{"delay":1000}');

method createErrorResponseOptions

protected createErrorResponseOptions: (
    url: string,
    status: number,
    message: string
) => ResponseOptions;

method createHeaders

protected abstract createHeaders: (headers: {
    [index: string]: string;
}) => HttpHeaders;

• Create standard HTTP headers object from hash map of header strings

  Parameter headers

method createPassThruBackend

protected abstract createPassThruBackend: () => PassThruBackend;

• create the function that passes unhandled requests through to the "real" backend.

method createQueryMap

protected abstract createQueryMap: (search: string) => Map<string, string[]>;

• return a search map from a location query/search string

method createResponse$

protected createResponse$: (
    resOptionsFactory: () => ResponseOptions,
    withDelay?: boolean
) => Observable<any>;

• Create a cold response Observable from a factory for ResponseOptions

  Parameter resOptionsFactory

  creates ResponseOptions when observable is subscribed

  Parameter withDelay

  if true (default), add simulated latency delay from configuration

method createResponse$fromResponseOptions$

protected abstract createResponse$fromResponseOptions$: (
    resOptions$: Observable<ResponseOptions>
) => Observable<any>;

• Create a Response observable from ResponseOptions observable.

method createResponseOptions$

protected createResponseOptions$: (
    resOptionsFactory: () => ResponseOptions
) => Observable<ResponseOptions>;

• Create a cold Observable of ResponseOptions.

  Parameter resOptionsFactory

  creates ResponseOptions when observable is subscribed

method delete

protected delete: ({
    collection,
    collectionName,
    headers,
    id,
    url,
}: RequestInfo_2) => ResponseOptions;

method findById

protected findById: <T extends { id: any }>(
    collection: T[],
    id: any
) => T | undefined;

• Find first instance of item in collection by item.id

  Parameter collection

  Parameter id

method genId

protected genId: <T extends { id: any }>(
    collection: T[],
    collectionName: string
) => any;

• Generate the next available id for item in this collection Use method from inMemDbService if it exists and returns a value, else delegates to genIdDefault.

  Parameter collection

  collection of items with id key property

method genIdDefault

protected genIdDefault: <T extends { id: any }>(
    collection: T[],
    collectionName: string
) => any;

• Default generator of the next available id for item in this collection This default implementation works only for numeric ids.

  Parameter collection

  collection of items with id key property

  Parameter collectionName

  name of the collection

method get

protected get: ({
    collection,
    collectionName,
    headers,
    id,
    query,
    url,
}: RequestInfo_2) => ResponseOptions;

method getJsonBody

protected abstract getJsonBody: (req: any) => any;

• Get JSON body from the request object

method getLocation

protected getLocation: (url: string) => UriInfo;

• Get location info from a url, even on server where document is not defined

method getPassThruBackend

protected getPassThruBackend: () => PassThruBackend;

• get or create the function that passes unhandled requests through to the "real" backend.

method getRequestInfoUtils

protected getRequestInfoUtils: () => RequestInfoUtilities;

• Get utility methods from this service instance. Useful within an HTTP method override

method getRequestMethod

protected abstract getRequestMethod: (req: any) => string;

• return canonical HTTP method name (lowercase) from the request object e.g. (req.method || 'get').toLowerCase();

  Parameter req

  request object from the http call

method handleRequest

protected handleRequest: (req: RequestCore) => Observable<any>;

• Process Request and return an Observable of Http Response object in the manner of a RESTy web api.

  Expect URI pattern in the form :base/:collectionName/:id? Examples: // for store with a 'customers' collection GET api/customers // all customers GET api/customers/42 // the character with id=42 GET api/customers?name=^j // 'j' is a regex; returns customers whose name starts with 'j' or 'J' GET api/customers.json/42 // ignores the ".json"

  Also accepts direct commands to the service in which the last segment of the apiBase is the word "commands" Examples: POST commands/resetDb, GET/POST commands/config - get or (re)set the config

  HTTP overrides: If the injected inMemDbService defines an HTTP method (lowercase) The request is forwarded to that method as in inMemDbService.get(requestInfo) which must return either an Observable of the response type for this http library or null|undefined (which means "keep processing").

method handleRequest_

protected handleRequest_: (req: RequestCore) => Observable<any>;

method indexOf

protected indexOf: (collection: any[], id: number) => number;

method isCollectionIdNumeric

protected isCollectionIdNumeric: <T extends { id: any }>(
    collection: T[],
    collectionName: string
) => boolean;

• return true if can determine that the collection's item.id is a number This implementation can't tell if the collection is empty so it assumes NO

method parseId

protected parseId: (
    collection: any[],
    collectionName: string,
    id: string
) => any;

• Parse the id as a number. Return original value if not a number.

method parseRequestUrl

protected parseRequestUrl: (url: string) => ParsedRequestUrl;

• Parses the request URL into a ParsedRequestUrl object. Parsing depends upon certain values of config: apiBase, host, and urlRoot.

  Configuring the apiBase yields the most interesting changes to parseRequestUrl behavior: When apiBase=undefined and url='http://localhost/api/collection/42' {base: 'api/', collectionName: 'collection', id: '42', ...} When apiBase='some/api/root/' and url='http://localhost/some/api/root/collection' {base: 'some/api/root/', collectionName: 'collection', id: undefined, ...} When apiBase='/' and url='http://localhost/collection' {base: '/', collectionName: 'collection', id: undefined, ...}

  The actual api base segment values are ignored. Only the number of segments matters. The following api base strings are considered identical: 'a/b' ~ 'some/api/' ~ `two/segments'

  To replace this default method, assign your alternative to your InMemDbService['parseRequestUrl']

method post

protected post: ({
    collection,
    collectionName,
    headers,
    id,
    req,
    resourceUrl,
    url,
}: RequestInfo_2) => ResponseOptions;

method put

protected put: ({
    collection,
    collectionName,
    headers,
    id,
    req,
    url,
}: RequestInfo_2) => ResponseOptions;

method removeById

protected removeById: (collection: any[], id: number) => boolean;

method resetDb

protected resetDb: (reqInfo?: RequestInfo_2) => Observable<boolean>;

• Tell your in-mem "database" to reset. returns Observable of the database because resetting it could be async

constructor

constructor(
    inMemDbService: InMemoryDbService,
    config: InMemoryBackendConfigArgs,
    xhrFactory: XhrFactory
);

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<
    HttpClientBackendService,
    [null, { optional: true }, null]
>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<HttpClientBackendService>;

method createHeaders

protected createHeaders: (headers: { [index: string]: string }) => HttpHeaders;

method createPassThruBackend

protected createPassThruBackend: () => HttpXhrBackend;

method createQueryMap

protected createQueryMap: (search: string) => Map<string, string[]>;

method createResponse$fromResponseOptions$

protected createResponse$fromResponseOptions$: (
    resOptions$: Observable<ResponseOptions>
) => Observable<HttpResponse<any>>;

method getJsonBody

protected getJsonBody: (req: HttpRequest<any>) => any;

method getRequestMethod

protected getRequestMethod: (req: HttpRequest<any>) => string;

method handle

handle: (req: HttpRequest<any>) => Observable<HttpEvent<any>>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<HttpClientInMemoryWebApiModule, never>;

property ɵinj

static ɵinj: i0.ɵɵInjectorDeclaration<HttpClientInMemoryWebApiModule>;

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    HttpClientInMemoryWebApiModule,
    never,
    never,
    never
>;

method forFeature

static forFeature: (
    dbCreator: Type<InMemoryDbService>,
    options?: InMemoryBackendConfigArgs
) => ModuleWithProviders<HttpClientInMemoryWebApiModule>;

• Enable and configure the in-memory web api in a lazy-loaded feature module. Same as forRoot. This is a feel-good method so you can follow the Angular style guide for lazy-loaded modules.

method forRoot

static forRoot: (
    dbCreator: Type<InMemoryDbService>,
    options?: InMemoryBackendConfigArgs
) => ModuleWithProviders<HttpClientInMemoryWebApiModule>;

• Redirect the Angular HttpClient XHR calls to in-memory data store that implements InMemoryDbService. with class that implements InMemoryDbService and creates an in-memory database.

  Usually imported in the root application module. Can import in a lazy feature module too, which will shadow modules loaded earlier

  Parameter dbCreator

  Class that creates seed data for in-memory database. Must implement InMemoryDbService.

  Parameter options

  Example 1

  HttpInMemoryWebApiModule.forRoot(dbCreator); HttpInMemoryWebApiModule.forRoot(dbCreator, {useValue: {delay:600}});

constructor

constructor(config?: InMemoryBackendConfigArgs);

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<InMemoryBackendConfig, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<InMemoryBackendConfig>;

property apiBase

apiBase?: string;

• The base path to the api, e.g, 'api/'. If not specified than parseRequestUrl assumes it is the first path segment in the request.

property caseSensitiveSearch

caseSensitiveSearch?: boolean;

• false (default) if search match should be case insensitive

property dataEncapsulation

dataEncapsulation?: boolean;

• false (default) put content directly inside the response body. true: encapsulate content in a data property inside the response body, { data: ... }.

property delay

delay?: number;

• delay (in ms) to simulate latency

property delete404

delete404?: boolean;

• false (default) should 204 when object-to-delete not found; true: 404

property host

host?: string;

• host for this service, e.g., 'localhost'

property passThruUnknownUrl

passThruUnknownUrl?: boolean;

• false (default) should pass unrecognized request URL through to original backend; true: 404

property post204

post204?: boolean;

• true (default) should NOT return the item (204) after a POST. false: return the item (200).

property post409

post409?: boolean;

• false (default) should NOT update existing item with POST. false: OK to update.

property put204

put204?: boolean;

• true (default) should NOT return the item (204) after a POST. false: return the item (200).

property put404

put404?: boolean;

• false (default) if item not found, create as new item; false: should 404.

property rootPath

rootPath?: string;

• root path _before_ any API call, e.g., ''

method createDb

abstract createDb: (
    reqInfo?: RequestInfo_2
) => {} | Observable<{}> | Promise<{}>;

• Creates an in-memory "database" hash whose keys are collection names and whose values are arrays of collection objects to return or update.

  returns Observable of the database because could have to create it asynchronously.

  This method must be safe to call repeatedly. Each time it should return a new object with new arrays containing new item objects. This condition allows the in-memory backend service to mutate the collections and their items without touching the original source data.

  The in-mem backend service calls this method without a value the first time. The service calls it with the RequestInfo when it receives a POST commands/resetDb request. Your InMemoryDbService can adjust its behavior accordingly.

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<InMemoryWebApiModule, never>;

property ɵinj

static ɵinj: i0.ɵɵInjectorDeclaration<InMemoryWebApiModule>;

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<InMemoryWebApiModule, never, never, never>;

method forFeature

static forFeature: (
    dbCreator: Type<InMemoryDbService>,
    options?: InMemoryBackendConfigArgs
) => ModuleWithProviders<InMemoryWebApiModule>;

• Enable and configure the in-memory web api in a lazy-loaded feature module. Same as forRoot. This is a feel-good method so you can follow the Angular style guide for lazy-loaded modules.

method forRoot

static forRoot: (
    dbCreator: Type<InMemoryDbService>,
    options?: InMemoryBackendConfigArgs
) => ModuleWithProviders<InMemoryWebApiModule>;

• Redirect BOTH Angular Http and HttpClient XHR calls to in-memory data store that implements InMemoryDbService. with class that implements InMemoryDbService and creates an in-memory database.

  Usually imported in the root application module. Can import in a lazy feature module too, which will shadow modules loaded earlier

  Parameter dbCreator

  Class that creates seed data for in-memory database. Must implement InMemoryDbService.

  Parameter options

  Example 1

  InMemoryWebApiModule.forRoot(dbCreator); InMemoryWebApiModule.forRoot(dbCreator, {useValue: {delay:600}});

property apiBase

apiBase: string;

property collectionName

collectionName: string;

property id

id: string;

property query

query: Map<string, string[]>;

property resourceUrl

resourceUrl: string;

method handle

handle: (req: any) => Observable<any>;

• Handle an HTTP request and return an Observable of HTTP response Both the request type and the response type are determined by the supporting HTTP library.

property url

url: string;

property urlWithParams

urlWithParams?: string;

property apiBase

apiBase: string;

property collection

collection: any;

property collectionName

collectionName: string;

property headers

headers: HttpHeaders;

property id

id: any;

property method

method: string;

property query

query: Map<string, string[]>;

property req

req: RequestCore;

property resourceUrl

resourceUrl: string;

property url

url: string;

property utils

utils: RequestInfoUtilities;

property createResponse$

createResponse$: (resOptionsFactory: () => ResponseOptions) => Observable<any>;

• Create a cold response Observable from a factory for ResponseOptions the same way that the in-mem backend service does.

  Parameter resOptionsFactory

  creates ResponseOptions when observable is subscribed

  Parameter withDelay

  if true (default), add simulated latency delay from configuration

method findById

findById: <T extends { id: any }>(collection: T[], id: any) => T | undefined;

• Find first instance of item in collection by item.id

  Parameter collection

  Parameter id

method getConfig

getConfig: () => InMemoryBackendConfigArgs;

• return the current, active configuration which is a blend of defaults and overrides

method getDb

getDb: () => {};

• Get the in-mem service's copy of the "database"

method getJsonBody

getJsonBody: (req: any) => any;

• Get JSON body from the request object

method getLocation

getLocation: (url: string) => UriInfo;

• Get location info from a url, even on server where document is not defined

method getPassThruBackend

getPassThruBackend: () => PassThruBackend;

• Get (or create) the "real" backend

method isCollectionIdNumeric

isCollectionIdNumeric: <T extends { id: any }>(
    collection: T[],
    collectionName: string
) => boolean;

• return true if can determine that the collection's item.id is a number

method parseRequestUrl

parseRequestUrl: (url: string) => ParsedRequestUrl;

• Parses the request URL into a ParsedRequestUrl object. Parsing depends upon certain values of config: apiBase, host, and urlRoot.

property body

body?: string | Object | ArrayBuffer | Blob;

• String, Object, ArrayBuffer or Blob representing the body of the Response.

property headers

headers?: HttpHeaders;

• Response headers

property status

status?: number;

• Http associated with the response.

property statusText

statusText?: string;

• Status text for the status code

property url

url?: string;

• request url

property anchor

anchor: string;

property authority

authority: string;

property directory

directory: string;

property file

file: string;

property host

host: string;

property password

password: string;

property path

path: string;

property port

port: string;

property protocol

protocol: string;

property query

query: string;

property relative

relative: string;

property source

source: string;

property user

user: string;

property userInfo

userInfo: string;