Class default

This is a FHIR client that is returned to you from the ready() call of the SMART API. You can also create it yourself if needed:

// BROWSER
const client = FHIR.client("https://r4.smarthealthit.org");

// SERVER
const client = smart(req, res).client("https://r4.smarthealthit.org");

Hierarchy (View Summary)

default
- default

Other

constructor

new default(environment: Adapter, state: string | ClientState): default
Validates the parameters and creates an instance.
Parameters
- environment: Adapter
- state: string | ClientState
Returns default
Overrides default.constructor
- Defined in src/Client.ts:212

api

api: Record<string, any> | undefined

The FhirJS API. NOTE: This will only be available if fhir.js is used. Otherwise it will be undefined.

`Readonly`encounter

encounter: { id: string | null; read: RequestFunction<Encounter> }

The client may be associated with a specific encounter, if the scopes permit that and if the back-end server supports that. This is a namespace for encounter-related functionality.

Type Declaration

id: string | null

The ID of the current encounter or null if there is no current encounter
read: RequestFunction<Encounter>

A method to fetch the current encounter resource from the FHIR server. If there is no encounter context, it will reject with an error.

Param: requestOptions
Any options to pass to the fetch call.

`Readonly`environment

environment: Adapter

The adapter to use to connect to the current environment. Currently we have:

BrowserAdapter - for browsers
NodeAdapter - for Express or vanilla NodeJS servers
HapiAdapter - for HAPI NodeJS servers

`Readonly`fhirBaseUrl

fhirBaseUrl: string

The state of the client instance is an object with various properties. It contains some details about how the client has been authorized and determines the behavior of the client instance. This state is persisted in SessionStorage in browsers or in request session on the servers.

`Readonly`patient

patient: {
    api?: Record<string, any>;
    id: string | null;
    read: RequestFunction<Patient>;
    request: <R = FetchResult>(
        requestOptions: string | URL | fhirclient.RequestOptions,
        fhirOptions?: FhirOptions,
    ) => Promise<R>;
}

A SMART app is typically associated with a patient. This is a namespace for the patient-related functionality of the client.

Type Declaration

Optionalapi?: Record<string, any>

This is the FhirJS Patient API. It will ONLY exist if the Client instance is "connected" to FhirJS.
id: string | null

The ID of the current patient or null if there is no current patient
read: RequestFunction<Patient>

A method to fetch the current patient resource from the FHIR server. If there is no patient context, it will reject with an error.

Param: requestOptions
Any options to pass to the fetch call.
request: <R = FetchResult>(
requestOptions: string | URL | fhirclient.RequestOptions,
fhirOptions?: FhirOptions,
) => Promise<R>
This is similar to [[request]] but it makes requests in the context of the current patient. For example, instead of doing
```
client.request("Observation?patient=" + client.patient.id)
```
you can do
```
client.patient.request("Observation")
```
The return type depends on the arguments. Typically it will be the response payload JSON object. Can also be a string or the Response object itself if we have received a non-json result, which allows us to handle even binary responses. Can also be a [[CombinedFetchResult]] object if the requestOptions.includeResponses has been set to true.

`Readonly`state

state: ClientState

`Readonly`user

user: {
    fhirUser: string | null;
    id: string | null;
    read: RequestFunction<Patient | Practitioner | RelatedPerson>;
    resourceType: string | null;
}

The client may be associated with a specific user, if the scopes permit that. This is a namespace for user-related functionality.

Type Declaration

fhirUser: string | null

Returns the profile of the logged_in user (if any), or null if the user is not available. This is a string having the shape {user type}/{user id}. For example Practitioner/abc or Patient/xyz.

See
client.getFhirUser()
id: string | null

The ID of the current user or null if there is no current user
read: RequestFunction<Patient | Practitioner | RelatedPerson>

A method to fetch the current user resource from the FHIR server. If there is no user context, it will reject with an error.

Param: requestOptions
Any options to pass to the fetch call.
resourceType: string | null

Returns the type of the logged-in user or null. The result can be Practitioner, Patient or RelatedPerson.

See
client.getUserType()

`Protected`fetchReferences

fetchReferences(
    resource: Resource,
    references: string[],
    graph: boolean,
    cache?: Record<string, any>,
    requestOptions?: Omit<fhirclient.RequestOptions, "url">,
): Promise<Record<string, any>>
Parameters
- resource: Resource
- references: string[]
- graph: boolean
- cache: Record<string, any> = {}
- requestOptions: Omit<fhirclient.RequestOptions, "url"> = {}
Returns Promise<Record<string, any>>
Inherited from default.fetchReferences
- Defined in src/FhirClient.ts:222

fhirRequest

fhirRequest<T = any>(uri: string | URL, options?: RequestOptions): Promise<T>
The method responsible for making all http requests
Type Parameters
- T = any
Parameters
- uri: string | URL
- options: RequestOptions = {}
Returns Promise<T>
Inherited from default.fhirRequest
- Defined in src/FhirClient.ts:361

getAuthorizationHeader

getAuthorizationHeader(): string | null
Builds and returns the value of the Authorization header that can be sent to the FHIR server

Returns string | null
- Defined in src/Client.ts:433

getEncounterId

getEncounterId(): string | null
Returns the ID of the selected encounter or null. You should have requested "launch/encounter" scope. Otherwise this will return null. Note that not all servers support the "launch/encounter" scope so this will be null if they don't.

Returns string | null
- Defined in src/Client.ts:314

getFhirRelease

getFhirRelease(): Promise<number>
Returns a promise that will be resolved with the numeric fhir version
- 2 for DSTU2
- 3 for STU3
- 4 for R4
- 0 if the version is not known
Returns Promise<number>
Inherited from default.getFhirRelease
- Defined in src/FhirClient.ts:413

getFhirUser

getFhirUser(): string | null
Returns the profile of the logged_in user (if any). This is a string having the following shape "{user type}/{user id}". For example: "Practitioner/abc" or "Patient/xyz".

Returns string | null
- Defined in src/Client.ts:390

getFhirVersion

getFhirVersion(): Promise<string>
Returns a promise that will be resolved with the fhir version as defined in the CapabilityStatement.

Returns Promise<string>
Inherited from default.getFhirVersion
- Defined in src/FhirClient.ts:400

getIdToken

getIdToken(): IDToken | null
Returns the (decoded) id_token if any. You need to request "openid" and "profile" scopes if you need to receive an id_token (if you need to know who the logged-in user is).

Returns IDToken | null
- Defined in src/Client.ts:347

getPatientId

getPatientId(): string | null
Returns the ID of the selected patient or null. You should have requested "launch/patient" scope. Otherwise this will return null.

Returns string | null
- Defined in src/Client.ts:280

getReferences

getReferences(
    resource: Resource,
    references: string[],
    requestOptions?: Omit<fhirclient.RequestOptions, "url">,
): Promise<Record<string, Resource>>
Fetches all references in the given resource, ignoring duplicates
Parameters
- resource: Resource
- references: string[]
- requestOptions: Omit<fhirclient.RequestOptions, "url"> = {}
Returns Promise<Record<string, Resource>>
Inherited from default.getReferences
- Defined in src/FhirClient.ts:284

getRequestDefaults

getRequestDefaults(): Promise<Partial<fhirclient.RequestOptions>>
Default request options to be used for every request.

Returns Promise<Partial<fhirclient.RequestOptions>>
Overrides default.getRequestDefaults
- Defined in src/Client.ts:463

getState

getState(path?: string): any
Returns a copy of the client state. Accepts a dot-separated path argument (same as for getPath) to allow for selecting specific properties. Examples:
```
client.getState(); // -> the entire state object
client.getState("serverUrl"); // -> the URL we are connected to
client.getState("tokenResponse.patient"); // -> The selected patient ID (if any)
```
Parameters
- path: string = ""
  The path (eg. "a.b.4.c")
Returns any
Whatever is found in the path or undefined
- Defined in src/Client.ts:877

getUserId

getUserId(): string | null
Returns the user ID or null.

Returns string | null
- Defined in src/Client.ts:407

getUserType

getUserType(): string | null
Returns the type of the logged-in user or null. The result can be "Practitioner", "Patient" or "RelatedPerson".

Returns string | null
- Defined in src/Client.ts:420

pages

pages(
bundleOrUrl: string | URL | Bundle<FhirResource>,
requestOptions?: RequestOptions,
): AsyncGenerator<Bundle<FhirResource>, void, unknown>
Given a FHIR Bundle or a URL pointing to a bundle, iterates over all pages. Note that this will automatically crawl through further pages (if any) but it will not detect previous pages. It is designed to be called on the first page and fetch any followup pages.
Parameters
- bundleOrUrl: string | URL | Bundle<FhirResource>
- OptionalrequestOptions: RequestOptions
Returns AsyncGenerator<Bundle<FhirResource>, void, unknown>
Inherited from default.pages
- Defined in src/FhirClient.ts:320

resolveReferences

resolveReferences(
    resource: Resource,
    references: string[],
    requestOptions?: Omit<fhirclient.RequestOptions, "url">,
): Promise<void>
Fetches all references in the given resource, ignoring duplicates, and then modifies the resource by "mounting" the resolved references in place
Parameters
- resource: Resource
- references: string[]
- requestOptions: Omit<fhirclient.RequestOptions, "url"> = {}
Returns Promise<void>
Inherited from default.resolveReferences
- Defined in src/FhirClient.ts:214

resources

resources(
bundleOrUrl: string | URL | Bundle<FhirResource>,
options?: RequestOptions,
): AsyncGenerator<FhirResource | undefined, void, unknown>
Given a FHIR Bundle or a URL pointing to a bundle, iterates over all entry resources. Note that this will also automatically crawl through further pages (if any)
Parameters
- bundleOrUrl: string | URL | Bundle<FhirResource>
- Optionaloptions: RequestOptions
Returns AsyncGenerator<FhirResource | undefined, void, unknown>
Inherited from default.resources
- Defined in src/FhirClient.ts:302

Request

create

create<R = Resource, O extends FetchOptions = {}>(
resource: Resource,
requestOptions?: O,
): Promise<O["includeResponse"] extends true ? CombinedFetchResult<R> : R>
Creates a new resource in a server-assigned location
Type Parameters
- R = Resource
- O extends FetchOptions = {}
Parameters
- resource: Resource
  A FHIR resource to be created
- OptionalrequestOptions: O
  Any options to be passed to the fetch call. Note that method and body will be ignored.
Returns Promise<O["includeResponse"] extends true ? CombinedFetchResult<R> : R>

See
http://hl7.org/fhir/http.html#create
Inherited from default.create
- Defined in src/FhirClient.ts:81

delete

delete<R = unknown>(url: string, requestOptions?: FetchOptions): Promise<R>
Removes an existing resource.
Type Parameters
- R = unknown
Parameters
- url: string
  Relative URI of the FHIR resource to be deleted (format: resourceType/id)
- requestOptions: FetchOptions = {}
  Any options (except method which will be fixed to DELETE) to be passed to the fetch call.
Returns Promise<R>

See
http://hl7.org/fhir/http.html#delete
Inherited from default.delete
- Defined in src/FhirClient.ts:131

patch

patch<ResolveType = Resource>(
    url: string,
    patch: JsonPatch,
    requestOptions?: FetchOptions,
): Promise<ResolveType>
Makes a JSON Patch to the given resource
Type Parameters
- ResolveType = Resource
  This method would typically resolve with the patched resource or reject with an OperationOutcome. However, this may depend on the server implementation or even on the request headers. For that reason, if the default resolve type (which is [[fhirclient.FHIR.Resource]]) does not work for you, you can pass in your own resolve type parameter.
Parameters
- url: string
  Relative URI of the FHIR resource to be patched (format: resourceType/id)
- patch: JsonPatch
  A JSON Patch array to send to the server, For details see https://datatracker.ietf.org/doc/html/rfc6902
- requestOptions: FetchOptions = {}
  Any options to be passed to the fetch call, except for method, url and body which cannot be overridden.
Returns Promise<ResolveType>

See
http://hl7.org/fhir/http.html#patch

Since
2.4.0
Inherited from default.patch
- Defined in src/FhirClient.ts:154

refresh

refresh(requestOptions?: RequestInit): Promise<ClientState>
Use the refresh token to obtain new access token. If the refresh token is expired (or this fails for any other reason) it will be deleted from the state, so that we don't enter into loops trying to re-authorize.

This method is typically called internally from [[request]] if certain request fails with 401.
Parameters
- requestOptions: RequestInit = {}
  Any options to pass to the fetch call. Most of them will be overridden, bit it might still be useful for passing additional request options or an abort signal.
Returns Promise<ClientState>
- Defined in src/Client.ts:716

refreshIfNeeded

refreshIfNeeded(requestOptions?: RequestInit): Promise<ClientState>
Checks if access token and refresh token are present. If they are, and if the access token is expired or is about to expire in the next 10 seconds, calls this.refresh() to obtain new access token.
Parameters
- requestOptions: RequestInit = {}
  Any options to pass to the fetch call. Most of them will be overridden, bit it might still be useful for passing additional request options or an abort signal.
Returns Promise<ClientState>
- Defined in src/Client.ts:690

request

request<T = any>(
    requestOptions: string | URL | fhirclient.RequestOptions,
    fhirOptions?: FhirOptions,
    _resolvedRefs?: JsonObject,
): Promise<T>
Type Parameters
- T = any
Parameters
- requestOptions: string | URL | fhirclient.RequestOptions
  Can be a string URL (relative to the serviceUrl), or an object which will be passed to fetch()
- fhirOptions: FhirOptions = {}
  Additional options to control the behavior
- _resolvedRefs: JsonObject = {}
  DO NOT USE! Used internally.
Returns Promise<T>
- Defined in src/Client.ts:479

update

update<R = Resource, O extends FetchOptions = {}>(
resource: Resource,
requestOptions?: O,
): Promise<O["includeResponse"] extends true ? CombinedFetchResult<R> : R>
Creates a new current version for an existing resource or creates an initial version if no resource already exists for the given id.
Type Parameters
- R = Resource
- O extends FetchOptions = {}
Parameters
- resource: Resource
  A FHIR resource to be updated
- OptionalrequestOptions: O
  Any options to be passed to the fetch call. Note that method and body will be ignored.
Returns Promise<O["includeResponse"] extends true ? CombinedFetchResult<R> : R>

See
http://hl7.org/fhir/http.html#update
Inherited from default.update
- Defined in src/FhirClient.ts:106

Utility

units

units: {
    any(pq: CodeValue): number;
    cm(__namedParameters: CodeValue): number;
    kg(__namedParameters: CodeValue): number;
} = units

byCode

byCode(
observations: Observation | Observation[],
property: string,
): ObservationMap
Groups the observations by code. Returns a map that will look like:
```
const map = client.byCodes(observations, "code");
// map = {
//     "55284-4": [ observation1, observation2 ],
//     "6082-2": [ observation3 ]
// }
```
Parameters
- observations: Observation | Observation[]
  Array of observations
- property: string
  The name of a CodeableConcept property to group by
Returns ObservationMap

Remarks
This should be deprecated and moved elsewhere. One should not have to obtain an instance of [[Client]] just to use utility functions like this.

Deprecated
- Defined in src/Client.ts:810

byCodes

byCodes(
observations: Observation | Observation[],
property: string,
): (...codes: string[]) => any[]
First groups the observations by code using byCode. Then returns a function that accepts codes as arguments and will return a flat array of observations having that codes. Example:
```
const filter = client.byCodes(observations, "category");
filter("laboratory") // => [ observation1, observation2 ]
filter("vital-signs") // => [ observation3 ]
filter("laboratory", "vital-signs") // => [ observation1, observation2, observation3 ]
```
Parameters
- observations: Observation | Observation[]
  Array of observations
- property: string
  The name of a CodeableConcept property to group by
Returns (...codes: string[]) => any[]

Remarks
This should be deprecated and moved elsewhere. One should not have to obtain an instance of [[Client]] just to use utility functions like this.

Deprecated
- Defined in src/Client.ts:835

getPath

getPath(obj: Record<string, any>, path?: string): any
Walks through an object (or array) and returns the value found at the provided path. This function is very simple so it intentionally does not support any argument polymorphism, meaning that the path can only be a dot-separated string. If the path is invalid returns undefined.
Parameters
- obj: Record<string, any>
  The object (or Array) to walk through
- path: string = ""
  The path (eg. "a.b.4.c")
Returns any
Whatever is found in the path or undefined

Remarks
This should be deprecated and moved elsewhere. One should not have to obtain an instance of [[Client]] just to use utility functions like this.

Deprecated
- Defined in src/Client.ts:861

Class default

Hierarchy (View Summary)

Index

Other

Request

Utility

Other

constructor

Parameters

Returns default

api

Readonlyencounter

Type Declaration

id: string | null

read: RequestFunction<Encounter>

Param: requestOptions

Readonlyenvironment

ReadonlyfhirBaseUrl

Readonlypatient

Type Declaration

Optionalapi?: Record<string, any>

id: string | null

read: RequestFunction<Patient>

Param: requestOptions

request: <R = FetchResult>( requestOptions: string | URL | fhirclient.RequestOptions, fhirOptions?: FhirOptions,) => Promise<R>

Readonlystate

Readonlyuser

Type Declaration

fhirUser: string | null

See

id: string | null

read: RequestFunction<Patient | Practitioner | RelatedPerson>

Param: requestOptions

resourceType: string | null

See

ProtectedfetchReferences

Parameters

Returns Promise<Record<string, any>>

fhirRequest

Type Parameters

Parameters

Returns Promise<T>

getAuthorizationHeader

Returns string | null

getEncounterId

Returns string | null

getFhirRelease

Returns Promise<number>

getFhirUser

Returns string | null

getFhirVersion

Returns Promise<string>

getIdToken

Returns IDToken | null

getPatientId

Returns string | null

getReferences

Parameters

Returns Promise<Record<string, Resource>>

getRequestDefaults

Returns Promise<Partial<fhirclient.RequestOptions>>

getState

Parameters

Returns any

getUserId

Returns string | null

getUserType

Returns string | null

pages

Parameters

Returns AsyncGenerator<Bundle<FhirResource>, void, unknown>

resolveReferences

Parameters

Returns Promise<void>

resources

Parameters

Returns AsyncGenerator<FhirResource | undefined, void, unknown>

Request

create

Type Parameters

`Readonly`encounter

`Readonly`environment

`Readonly`fhirBaseUrl

`Readonly`patient

`Optional`api?: Record<string, any>

request: <R = FetchResult>(
requestOptions: string | URL | fhirclient.RequestOptions,
fhirOptions?: FhirOptions,
) => Promise<R>

`Readonly`state

`Readonly`user

`Protected`fetchReferences