@medplum/core 0.9.1 → 0.9.2

package/README.md

@@ -1,7 +1,3 @@
-# Medplum
-
-Medplum is a healthcare platform that helps you quickly develop high-quality compliant applications. Medplum includes a FHIR server, React component library, and developer app.
-
 # Medplum JS Client Library
 
 The Medplum JS Client Library is a pure TypeScript library for calling a FHIR server from the browser.
@@ -16,13 +12,25 @@ The Medplum JS Client Library is a pure TypeScript library for calling a FHIR se
 
 ## Installation
 
-```
-npm install medplum
+Add as a dependency:
+
+```bash
+npm install @medplum/core
 ```
 
 ## Basic Usage
 
-```typescript
+Create a new `MedplumClient`:
+
+```ts
+import { MedplumClient } from '@medplum/core';
+
+const medplum = new MedplumClient();
+```
+
+Create a `MedplumClient` with additional configuration options:
+
+```ts
 import { MedplumClient } from '@medplum/core';
 
 const medplum = new MedplumClient({
@@ -31,12 +39,11 @@ const medplum = new MedplumClient({
 });
 ```
 
-## Authenticating with OAuth
-
-Authenticate with a FHIR server via OAuth2 redirect:
+## Authenticate with client credenials
 
-```typescript
-medplum.signInWithRedirect().then((user) => console.log(user));
+```ts
+const medplum = new MedplumClient();
+medplum.clientCredentials(MY_CLIENT_ID, MY_CLIENT_SECRET);
 ```
 
 ## Authenticating with Medplum
@@ -50,25 +57,39 @@ Before you begin
 
 After that, you can use the `startLogin()` method:
 
-```typescript
+```ts
 const loginResult = await medplum.startLogin(email, password, remember);
 const profile = await medplum.processCode(loginResult.code);
 console.log(profile);
 ```
 
+## Authenticating with OAuth
+
+Authenticate with a FHIR server via OAuth2 redirect:
+
+```ts
+medplum.signInWithRedirect().then((user) => console.log(user));
+```
+
 ## Search
 
 Search for any resource using a [FHIR search](https://www.hl7.org/fhir/search.html) string:
 
-```typescript
+```ts
+search<T extends Resource>(query: string | SearchRequest, options: RequestInit = {}): Promise<Bundle<T>>
+```
+
+Example:
+
+```ts
 medplum.search('Patient?given=eve').then((bundle) => {
   bundle.entry.forEach((entry) => console.log(entry.resource));
 });
 ```
 
-Search using a structured object:
+Example using a structured object:
 
-```typescript
+```ts
 medplum
   .search({
     resourceType: 'Patient',
@@ -87,10 +108,16 @@ medplum
 
 ## Create
 
-Create a new resource:
+[Create resource](https://www.hl7.org/fhir/http.html#create):
+
+```ts
+createResource<T extends Resource>(resource: T): Promise<T>
+```
 
-```typescript
-medplum.create({
+Example:
+
+```ts
+medplum.createResource({
   resourceType: 'Observation',
   subject: {
     reference: 'Patient/123',
@@ -102,26 +129,128 @@ medplum.create({
 });
 ```
 
-## Read
+## Read a resource
+
+[Read a resource by ID](https://www.hl7.org/fhir/http.html#read):
+
+```ts
+readResource<T extends Resource>(resourceType: string, id: string): Promise<T>
+```
+
+Example:
+
+```ts
+const patient = await medplum.readResource('Patient', '123');
+```
+
+## Read resource history
+
+[Read resource history](https://www.hl7.org/fhir/http.html#history):
+
+```ts
+readHistory<T extends Resource>(resourceType: string, id: string): Promise<Bundle<T>>
+```
+
+Example:
+
+```ts
+const historyBundle = await medplum.readHistory('Patient', '123');
+```
+
+## Read resource version
+
+[Read a specific version](https://www.hl7.org/fhir/http.html#vread):
+
+```ts
+readVersion<T extends Resource>(resourceType: string, id: string, vid: string): Promise<T>
+```
+
+Example:
+
+```ts
+const version = await medplum.readVersion('Patient', '123', '456');
+```
+
+## Update a resource
+
+[Update a resource](https://www.hl7.org/fhir/http.html#update):
+
+```ts
+updateResource<T extends Resource>(resource: T): Promise<T>
+```
+
+Example:
+
+```ts
+const result = await medplum.updateResource({
+  resourceType: 'Patient',
+  id: '123',
+  name: [{
+   family: 'Smith',
+   given: ['John']
+  }]
+});
+console.log(result.meta.versionId);
+```
+
+## Delete a resource
 
-Read a resource by ID:
+[Delete a resource](https://www.hl7.org/fhir/http.html#delete):
 
-```typescript
-medplum.read('Patient', '123');
+```ts
+deleteResource(resourceType: string, id: string): Promise<any>
 ```
 
-Read resource history:
+Example:
 
-```typescript
-medplum.readHistory('Patient', '123');
+```ts
+await medplum.deleteResource('Patient', '123');
 ```
 
-Read a specific version:
+## Patch a resource
+
+[Patch a resource](https://www.hl7.org/fhir/http.html#patch):
 
-```typescript
-medplum.readVersion('Patient', '123', '456');
+```ts
+patchResource<T extends Resource>(resourceType: string, id: string, operations: Operation[]): Promise<T>
 ```
 
+Example:
+
+```ts
+const result = await medplum.patchResource('Patient', '123', [
+  {op: 'replace', path: '/name/0/family', value: 'Smith'},
+]);
+console.log(result.meta.versionId);
+```
+
+## GraphQL
+
+[Execute a GraphQL query](https://www.hl7.org/fhir/graphql.html):
+
+```ts
+graphql(query: string, options?: RequestInit): Promise<any>
+```
+
+Example:
+
+```ts
+const result = await graphql(`
+  {
+    PatientList(name: "Alice") {
+      name {
+        given,
+        family
+      }
+    }
+  }
+`);
+```
+
+## About Medplum
+
+Medplum is a healthcare platform that helps you quickly develop high-quality compliant applications. Medplum includes a FHIR server, React component library, and developer app.
+
 ## License
 
 Apache 2.0. Copyright &copy; Medplum 2022

package/dist/cjs/index.js

@@ -401,33 +401,59 @@
     /**
      * Resource equality.
      * Ignores meta.versionId and meta.lastUpdated.
-     * See: https://dmitripavlutin.com/how-to-compare-objects-in-javascript/#4-deep-equality
      * @param object1 The first object.
      * @param object2 The second object.
      * @returns True if the objects are equal.
      */
     function deepEquals(object1, object2, path) {
-        let keys1 = Object.keys(object1);
-        let keys2 = Object.keys(object2);
-        if (path === 'meta') {
-            keys1 = keys1.filter((k) => k !== 'versionId' && k !== 'lastUpdated' && k !== 'author');
-            keys2 = keys2.filter((k) => k !== 'versionId' && k !== 'lastUpdated' && k !== 'author');
+        if (object1 === object2) {
+            return true;
+        }
+        if (isEmpty(object1) && isEmpty(object2)) {
+            return true;
+        }
+        if (isEmpty(object1) || isEmpty(object2)) {
+            return false;
         }
-        if (keys1.length !== keys2.length) {
+        if (Array.isArray(object1) && Array.isArray(object2)) {
+            return deepEqualsArray(object1, object2);
+        }
+        if (Array.isArray(object1) || Array.isArray(object2)) {
+            return false;
+        }
+        if (isObject(object1) && isObject(object2)) {
+            return deepEqualsObject(object1, object2, path);
+        }
+        if (isObject(object1) || isObject(object2)) {
             return false;
         }
-        for (const key of keys1) {
+        return false;
+    }
+    function deepEqualsArray(array1, array2) {
+        if (array1.length !== array2.length) {
+            return false;
+        }
+        for (let i = 0; i < array1.length; i++) {
+            if (!deepEquals(array1[i], array2[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function deepEqualsObject(object1, object2, path) {
+        const keySet = new Set();
+        Object.keys(object1).forEach((k) => keySet.add(k));
+        Object.keys(object2).forEach((k) => keySet.add(k));
+        if (path === 'meta') {
+            keySet.delete('versionId');
+            keySet.delete('lastUpdated');
+            keySet.delete('author');
+        }
+        for (const key of keySet) {
             const val1 = object1[key];
             const val2 = object2[key];
-            if (isObject(val1) && isObject(val2)) {
-                if (!deepEquals(val1, val2, key)) {
-                    return false;
-                }
-            }
-            else {
-                if (val1 !== val2) {
-                    return false;
-                }
+            if (!deepEquals(val1, val2, key)) {
+                return false;
             }
         }
         return true;
@@ -725,6 +751,7 @@
         }
     }
 
+    const DEFAULT_SEARCH_COUNT = 20;
     /**
      * Search operators.
      * These operators represent "modifiers" and "prefixes" in FHIR search.
@@ -792,15 +819,15 @@
         let filters = undefined;
         let sortRules = undefined;
         let fields = undefined;
-        let page = undefined;
+        let offset = undefined;
         let count = undefined;
         let total = undefined;
         params.forEach((value, key) => {
             if (key === '_fields') {
                 fields = value.split(',');
             }
-            else if (key === '_page') {
-                page = parseInt(value);
+            else if (key === '_offset') {
+                offset = parseInt(value);
             }
             else if (key === '_count') {
                 count = parseInt(value);
@@ -821,7 +848,7 @@
             resourceType,
             filters,
             fields,
-            page,
+            offset,
             count,
             total,
             sortRules,
@@ -897,13 +924,13 @@
         if (definition.sortRules && definition.sortRules.length > 0) {
             params.push(formatSortRules(definition.sortRules));
         }
-        if (definition.page && definition.page > 0) {
-            params.push('_page=' + definition.page);
+        if (definition.offset !== undefined) {
+            params.push('_offset=' + definition.offset);
         }
-        if (definition.count && definition.count > 0) {
+        if (definition.count !== undefined) {
             params.push('_count=' + definition.count);
         }
-        if (definition.total) {
+        if (definition.total !== undefined) {
             params.push('_total=' + encodeURIComponent(definition.total));
         }
         if (params.length === 0) {
@@ -2120,7 +2147,7 @@
                 return undefined;
             }
             const obj = yield response.json();
-            if (obj.resourceType === 'OperationOutcome' && !isOk(obj)) {
+            if ((obj === null || obj === void 0 ? void 0 : obj.resourceType) === 'OperationOutcome' && !isOk(obj)) {
                 return Promise.reject(obj);
             }
             return obj;
@@ -2712,6 +2739,7 @@
     }
 
     exports.COMPONENT_SEPARATOR = COMPONENT_SEPARATOR;
+    exports.DEFAULT_SEARCH_COUNT = DEFAULT_SEARCH_COUNT;
     exports.FIELD_SEPARATOR = FIELD_SEPARATOR;
     exports.Hl7Field = Hl7Field;
     exports.Hl7Message = Hl7Message;