@medplum/core 2.1.3 → 2.1.5

package/dist/types/base-schema.d.ts

@@ -0,0 +1,7 @@
+import { InternalSchemaElement, InternalTypeSchema } from './typeschema/types';
+export type BaseSchema = Record<string, {
+    elements: Record<string, Partial<InternalSchemaElement>>;
+}>;
+export declare function compressElement(element: InternalSchemaElement): Partial<InternalSchemaElement>;
+export declare function inflateElement(partial: Partial<InternalSchemaElement>): InternalSchemaElement;
+export declare function inflateBaseSchema(base: BaseSchema): Record<string, InternalTypeSchema>;

package/dist/types/client.d.ts

@@ -2,10 +2,10 @@ import { AccessPolicy, Agent, Attachment, Binary, BulkDataExport, Bundle, Commun
 /** @ts-ignore */
 import type { CustomTableLayout, TDocumentDefinitions, TFontDictionary } from 'pdfmake/interfaces';
 import { EventTarget } from './eventtarget';
+import { FhircastConnection, FhircastEventContext, FhircastEventName, SubscriptionRequest } from './fhircast';
 import { Hl7Message } from './hl7';
 import { ReadablePromise } from './readablepromise';
 import { ClientStorage } from './storage';
-import { IndexedStructureDefinition } from './types';
 import { CodeChallengeMethod, ProfileResource } from './utils';
 export declare const MEDPLUM_VERSION: string;
 /**
@@ -907,15 +907,6 @@ export declare class MedplumClient extends EventTarget {
      * @returns The resource if available; undefined otherwise.
      */
     readReference<T extends Resource>(reference: Reference<T>, options?: RequestInit): ReadablePromise<T>;
-    /**
-     * Returns a cached schema for a resource type.
-     * If the schema is not cached, returns undefined.
-     * It is assumed that a client will call requestSchema before using this method.
-     * @category Schema
-     * @returns The schema if immediately available, undefined otherwise.
-     * @deprecated Use globalSchema instead.
-     */
-    getSchema(): IndexedStructureDefinition;
     /**
      * Requests the schema for a resource type.
      * If the schema is already cached, the promise is resolved immediately.
@@ -923,7 +914,7 @@ export declare class MedplumClient extends EventTarget {
      * @param resourceType The FHIR resource type.
      * @returns Promise to a schema with the requested resource type.
      */
-    requestSchema(resourceType: string): Promise<IndexedStructureDefinition>;
+    requestSchema(resourceType: string): Promise<void>;
     /**
      * Reads resource history by resource type and ID.
      *
@@ -1455,9 +1446,9 @@ export declare class MedplumClient extends EventTarget {
      */
     getProfile(): ProfileResource | undefined;
     /**
-     * Returns the current user profile resource if available.
+     * Returns the current user profile resource, retrieving form the server if necessary.
      * This method waits for loading promises.
-     * @returns The current user profile resource if available.
+     * @returns The current user profile resource.
      * @category User Profile
      */
     getProfileAsync(): Promise<ProfileResource | undefined>;
@@ -1667,6 +1658,43 @@ export declare class MedplumClient extends EventTarget {
      * @param clientSecret The client secret.
      */
     setBasicAuth(clientId: string, clientSecret: string): void;
+    /**
+     * Subscribes to a specified topic, listening for a list of specified events.
+     *
+     * Once you have the `SubscriptionRequest` returned from this method, you can call `fhircastConnect(subscriptionRequest)` to connect to the subscription stream.
+     *
+     * @category FHIRcast
+     * @param topic The topic to publish to. Usually a UUID.
+     * @param events An array of event names to listen for.
+     * @returns A `Promise` that resolves once the request completes, or rejects if it fails.
+     */
+    fhircastSubscribe(topic: string, events: FhircastEventName[]): Promise<SubscriptionRequest>;
+    /**
+     * Unsubscribes from the specified topic.
+     *
+     * @category FHIRcast
+     * @param subRequest A `SubscriptionRequest` representing a subscription to cancel. Mode will be set to `unsubscribe` automatically.
+     * @returns A `Promise` that resolves when request to unsubscribe is completed.
+     */
+    fhircastUnsubscribe(subRequest: SubscriptionRequest): Promise<void>;
+    /**
+     * Connects to a `FHIRcast` session.
+     *
+     * @category FHIRcast
+     * @param subRequest The `SubscriptionRequest` to use for connecting.
+     * @returns A `FhircastConnection` which emits lifecycle events for the `FHIRcast` WebSocket connection.
+     */
+    fhircastConnect(subRequest: SubscriptionRequest): FhircastConnection;
+    /**
+     * Publishes a new context to a given topic for a specified event type.
+     *
+     * @category FHIRcast
+     * @param topic The topic to publish to. Usually a UUID.
+     * @param event The name of the event to publish an updated context for, ie. `patient-open`.
+     * @param context The updated context containing resources relevant to this event.
+     * @returns A `Promise` that resolves once the request completes, or rejects if it fails.
+     */
+    fhircastPublish(topic: string, event: FhircastEventName, context: FhircastEventContext | FhircastEventContext[]): Promise<void>;
     /**
      * Invite a user to a project.
      * @param projectId The project ID.

package/dist/types/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const UCUM = "http://unitsofmeasure.org";
+export declare const LOINC = "http://loinc.org";
+export declare const SNOMED = "http://snomed.info/sct";
+export declare const RXNORM = "http://www.nlm.nih.gov/research/umls/rxnorm";
+export declare const CPT = "http://www.ama-assn.org/go/cpt";
+export declare const ICD10 = "http://hl7.org/fhir/sid/icd-10";

package/dist/types/eventtarget.d.ts

@@ -10,3 +10,9 @@ export declare class EventTarget {
     removeEventListener(type: string, callback: EventListener): void;
     dispatchEvent(event: Event): boolean;
 }
+export declare class TypedEventTarget<TEvents extends Record<string, Event>> {
+    private emitter;
+    dispatchEvent<TEventType extends keyof TEvents & string>(event: TEvents[TEventType]): void;
+    addEventListener<TEventType extends keyof TEvents & string>(type: TEventType, handler: (event: TEvents[TEventType]) => void): void;
+    removeEventListener<TEventType extends keyof TEvents & string>(type: TEventType, handler: (event: TEvents[TEventType]) => void): void;
+}

package/dist/types/fhircast/index.d.ts

@@ -0,0 +1,115 @@
+import type { Resource } from '@medplum/fhirtypes';
+import { TypedEventTarget } from '../eventtarget';
+declare const FHIRCAST_EVENT_NAMES: {
+    readonly 'patient-open': "patient-open";
+    readonly 'patient-close': "patient-close";
+    readonly 'imagingstudy-open': "imagingstudy-open";
+    readonly 'imagingstudy-close': "imagingstudy-close";
+};
+declare const FHIRCAST_RESOURCE_TYPES: readonly ["Patient", "Encounter", "ImagingStudy"];
+export type FhircastEventName = keyof typeof FHIRCAST_EVENT_NAMES;
+export type FhircastResourceType = (typeof FHIRCAST_RESOURCE_TYPES)[number];
+/**
+ * Checks if a `ResourceType` can be used in a `FHIRcast` context.
+ *
+ * @param resourceType A `ResourceType` to test.
+ * @returns `true` if this is a resource type associated with `FHIRcast` contexts, otherwise returns `false`.
+ */
+export declare function isFhircastResourceType(resourceType: FhircastResourceType): boolean;
+/**
+ * A `FHIRcast` subscription request.
+ *
+ * Can be passed to `MedplumClient.fhircastConnect` or `MedplumClient.fhircastUnsubscribe` to either open a `FHIRcast` connection, or unsubscribe from the subscription.
+ */
+export type SubscriptionRequest = {
+    channelType: 'websocket';
+    mode: 'subscribe' | 'unsubscribe';
+    events: FhircastEventName[];
+    topic: string;
+    endpoint: string;
+};
+export type PendingSubscriptionRequest = Omit<SubscriptionRequest, 'endpoint'>;
+declare const FHIRCAST_CONTEXT_KEY_LOOKUP: {
+    readonly study: "ImagingStudy";
+    readonly patient: "Patient";
+    readonly encounter: "Encounter";
+};
+type FhircastEventContextMap = typeof FHIRCAST_CONTEXT_KEY_LOOKUP;
+type FhircastEventContextKey = keyof FhircastEventContextMap;
+export type FhircastEventContext<K extends FhircastEventContextKey = FhircastEventContextKey> = {
+    key: K;
+    resource: Resource & {
+        resourceType: FhircastEventContextMap[K];
+        id: string;
+    };
+};
+export type FhircastEventPayload = {
+    'hub.topic': string;
+    'hub.event': string;
+    context: FhircastEventContext[];
+};
+export type FhircastMessagePayload = {
+    timestamp: string;
+    id: string;
+    event: FhircastEventPayload;
+};
+export declare function isCompletedSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): subscriptionRequest is SubscriptionRequest;
+/**
+ * Creates a serialized url-encoded payload for a `FHIRcast` subscription from a `SubscriptionRequest` object that can be directly used in an HTTP request to the Hub.
+ *
+ * @param subscriptionRequest An object representing a subscription request.
+ * @returns A serialized subscription in url-encoded form.
+ */
+export declare function serializeFhircastSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): string;
+/**
+ * Validates that a `SubscriptionRequest`.
+ *
+ * @param subscriptionRequest The `SubscriptionRequest` to validate.
+ * @returns A `boolean` indicating whether or not the `SubscriptionRequest` is valid.
+ */
+export declare function validateFhircastSubscriptionRequest(subscriptionRequest: SubscriptionRequest | PendingSubscriptionRequest): boolean;
+/**
+ * Creates a serializable JSON payload for the `FHIRcast` protocol
+ *
+ * @param topic The topic that this message will be published on. Usually a UUID.
+ * @param event The event name, ie. "patient-open" or "patient-close".
+ * @param context The updated context, containing new versions of resources related to this event.
+ * @returns A serializable `FhircastMessagePayload`.
+ */
+export declare function createFhircastMessagePayload(topic: string, event: FhircastEventName, context: FhircastEventContext | FhircastEventContext[]): FhircastMessagePayload;
+export type FhircastConnectEvent = {
+    type: 'connect';
+};
+export type FhircastMessageEvent = {
+    type: 'message';
+    payload: FhircastMessagePayload;
+};
+export type FhircastDisconnectEvent = {
+    type: 'disconnect';
+};
+export type FhircastSubscriptionEventMap = {
+    connect: FhircastConnectEvent;
+    message: FhircastMessageEvent;
+    disconnect: FhircastDisconnectEvent;
+};
+/**
+ * A class representing a `FHIRcast` connection.
+ *
+ * `FhircastConnection` extends `EventTarget` and emits 3 lifecycle events:
+ * 1. `connect` - An event to signal when a WebSocket connection has been opened. Fired as soon as a WebSocket emits `open`.
+ * 2. `message` - Contains a `payload` field containing a `FHIRcast` message payload exactly as it comes in over WebSockets.
+ * 3. `disconnect` - An event to signal when a WebSocket connection has been closed. Fired as soon as a WebSocket emits `close`.
+ *
+ * To close the connection, call `connection.disconnect()` and listen to the `disconnect` event to know when the connection has been disconnected.
+ */
+export declare class FhircastConnection extends TypedEventTarget<FhircastSubscriptionEventMap> {
+    subRequest: SubscriptionRequest;
+    private websocket;
+    /**
+     * Creates a new `FhircastConnection`.
+     * @param subRequest The subscription request to initialize the connection from.
+     */
+    constructor(subRequest: SubscriptionRequest);
+    disconnect(): void;
+}
+export {};

package/dist/types/fhircast/test-utils.d.ts

@@ -0,0 +1,2 @@
+import { FhircastEventContext, FhircastResourceType } from '.';
+export declare function createFhircastMessageContext(resourceType: Lowercase<FhircastResourceType>, resourceId: string): FhircastEventContext;

package/dist/types/fhirmapper/tokenize.d.ts

@@ -1,2 +1,2 @@
-import { Token } from '../fhirlexer';
+import { Token } from '../fhirlexer/tokenize';
 export declare function tokenize(str: string): Token[];

package/dist/types/fhirpath/atoms.d.ts

@@ -1,4 +1,4 @@
-import { Atom, AtomContext, InfixOperatorAtom, PrefixOperatorAtom } from '../fhirlexer';
+import { Atom, AtomContext, InfixOperatorAtom, PrefixOperatorAtom } from '../fhirlexer/parse';
 import { TypedValue } from '../types';
 export declare class FhirPathAtom implements Atom {
     readonly original: string;

package/dist/types/fhirpath/functions.d.ts

@@ -1,4 +1,4 @@
-import { Atom, AtomContext } from '../fhirlexer';
+import { Atom, AtomContext } from '../fhirlexer/parse';
 import { TypedValue } from '../types';
 export type FhirPathFunction = (context: AtomContext, input: TypedValue[], ...args: Atom[]) => TypedValue[];
 export declare const functions: Record<string, FhirPathFunction>;

package/dist/types/fhirpath/parse.d.ts

@@ -1,4 +1,4 @@
-import { ParserBuilder } from '../fhirlexer';
+import { ParserBuilder } from '../fhirlexer/parse';
 import { TypedValue } from '../types';
 import { FhirPathAtom } from './atoms';
 /**

package/dist/types/fhirpath/tokenize.d.ts

@@ -1,4 +1,4 @@
-import { Token } from '../fhirlexer';
+import { Token } from '../fhirlexer/tokenize';
 export declare const FHIRPATH_KEYWORDS: string[];
 export declare const FHIRPATH_OPERATORS: string[];
 export declare function tokenize(str: string): Token[];

package/dist/types/filter/tokenize.d.ts

@@ -1,2 +1,2 @@
-import { Token } from '../fhirlexer';
+import { Token } from '../fhirlexer/tokenize';
 export declare function tokenize(str: string): Token[];

package/dist/types/index.d.ts

@@ -1,16 +1,21 @@
 export * from './access';
 export * from './base64';
+export * from './base-schema';
 export * from './bundle';
 export * from './cache';
 export * from './client';
 export * from './config';
+export * from './constants';
 export * from './contenttype';
 export * from './crypto';
 export * from './eventtarget';
-export * from './fhirlexer';
-export * from './fhirmapper';
-export * from './fhirpath';
-export * from './filter';
+export * from './fhircast';
+export * from './fhirlexer/parse';
+export * from './fhirmapper/parse';
+export * from './fhirpath/parse';
+export * from './fhirpath/utils';
+export * from './filter/parse';
+export * from './filter/types';
 export * from './format';
 export * from './hl7';
 export * from './jwt';

package/dist/types/schema.d.ts

@@ -1,36 +1,4 @@
-import { OperationOutcomeIssue, Resource } from '@medplum/fhirtypes';
-/**
- * Returns true if the given string is a valid FHIR resource type.
- *
- * ```ts
- * isResourceType('Patient'); // true
- * isResourceType('XYZ'); // false
- * ```
- *
- * Note that this depends on globalSchema, which is populated by the StructureDefinition loader.
- *
- * In a server context, you can load all schema definitions:
- *
- * ```ts
- * import { indexStructureDefinitionBundle } from '@medplum/core';
- * import { readJson } from '@medplum/definitions';
- * import { Bundle } from '@medplum/fhirtypes';
- *
- * indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
- * ```
- *
- * In a client context, you can load the schema definitions using MedplumClient:
- *
- * ```ts
- * import { MedplumClient } from '@medplum/core';
- *
- * const medplum = new MedplumClient();
- * await medplum.requestSchema('Patient');
- * ```
- * @param resourceType The candidate resource type string.
- * @returns True if the resource type is a valid FHIR resource type.
- */
-export declare function isResourceType(resourceType: string): boolean;
+import { OperationOutcomeIssue } from '@medplum/fhirtypes';
 /**
  * Validates that the given string is a valid FHIR resource type.
  * On success, silently returns void.
@@ -64,77 +32,6 @@ export declare function isResourceType(resourceType: string): boolean;
  * @param resourceType The candidate resource type string.
  */
 export declare function validateResourceType(resourceType: string): void;
-/**
- * Validates a candidate FHIR resource object.
- * On success, silently returns void.
- * On failure, throws an OperationOutcomeError with issues for each violation.
- *
- * ```ts
- * validateResource({ resourceType: 'Patient' }); // nothing
- * validateResource({ resourceType: 'XYZ' }); // throws OperationOutcomeError
- * ```
- *
- * Note that this depends on globalSchema, which is populated by the StructureDefinition loader.
- *
- * In a server context, you can load all schema definitions:
- *
- * ```ts
- * import { indexStructureDefinitionBundle } from '@medplum/core';
- * import { readJson } from '@medplum/definitions';
- * import { Bundle } from '@medplum/fhirtypes';
- *
- * indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
- * ```
- *
- * In a client context, you can load the schema definitions using MedplumClient:
- *
- * ```ts
- * import { MedplumClient } from '@medplum/core';
- *
- * const medplum = new MedplumClient();
- * await medplum.requestSchema('Patient');
- * ```
- * @param resource The candidate resource.
- * @deprecated use validate() instead
- */
-export declare function validateResource<T extends Resource>(resource: T): void;
-export declare class FhirSchemaValidator<T extends Resource> {
-    private readonly issues;
-    private readonly root;
-    constructor(root: T);
-    validate(): void;
-    private validateObject;
-    private checkProperties;
-    private checkProperty;
-    private checkPropertyValue;
-    private validatePrimitiveType;
-    private validateString;
-    private validateNumber;
-    private checkAdditionalProperties;
-    /**
-     * Checks if the given property is allowed on the given object.
-     * @param path The path of the current object.
-     * @param key The key of a property to check.
-     * @param typedValue The current object.
-     * @param propertyDefinitions The property definitions of the current object.
-     */
-    private checkAdditionalProperty;
-    /**
-     * Checks the element for a primitive.
-     *
-     * FHIR elements with primitive data types are represented in two parts:
-     *   1) A JSON property with the name of the element, which has a JSON type of number, boolean, or string
-     *   2) a JSON property with _ prepended to the name of the element, which, if present, contains the value's id and/or extensions
-     *
-     * See: https://hl7.org/fhir/json.html#primitive
-     * @param path The path to the property
-     * @param key The key in the current typed value.
-     * @param typedValue The current typed value.
-     * @returns True if the primitive element is valid.
-     */
-    private checkPrimitiveElement;
-    private createIssue;
-}
 /**
  * Recursively checks for null values in an object.
  *

package/dist/types/search/details.d.ts

@@ -1,5 +1,6 @@
-import { ElementDefinition, SearchParameter } from '@medplum/fhirtypes';
-import { Atom } from '../fhirlexer';
+import { SearchParameter } from '@medplum/fhirtypes';
+import { Atom } from '../fhirlexer/parse';
+import { InternalSchemaElement } from '../typeschema/types';
 export declare enum SearchParameterType {
     BOOLEAN = "BOOLEAN",
     NUMBER = "NUMBER",
@@ -15,7 +16,7 @@ export declare enum SearchParameterType {
 export interface SearchParameterDetails {
     readonly columnName: string;
     readonly type: SearchParameterType;
-    readonly elementDefinitions?: ElementDefinition[];
+    readonly elementDefinitions?: InternalSchemaElement[];
     readonly array?: boolean;
 }
 /**

package/dist/types/search/search.d.ts

@@ -1,4 +1,5 @@
 import { Resource } from '@medplum/fhirtypes';
+import { TypedValue } from '../types';
 export declare const DEFAULT_SEARCH_COUNT = 20;
 export interface SearchRequest<T extends Resource = Resource> {
     readonly resourceType: T['resourceType'];
@@ -82,6 +83,16 @@ export declare function parseSearchDefinition<T extends Resource = Resource>(url
  * @returns Parsed search definition.
  */
 export declare function parseCriteriaAsSearchRequest(criteria: string): SearchRequest;
+/**
+ * Parses an extended FHIR search criteria string (i.e. application/x-fhir-query), evaluating
+ * any embedded FHIRPath subexpressions (e.g. `{{ %patient.id }}`) with the provided variables.
+ *
+ * @see https://hl7.org/fhir/fhir-xquery.html
+ * @param query The X-Fhir-Query string to parse
+ * @param variables Values to pass into embedded FHIRPath expressions
+ * @returns The parsed search request
+ */
+export declare function parseXFhirQuery(query: string, variables: Record<string, TypedValue>): SearchRequest;
 /**
  * Formats a search definition object into a query string.
  * Note: The return value does not include the resource type.