@ovok/core 0.4.49-dev.495 → 0.4.49-dev.497

package/dist/next/resources/localization/locales-resource.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalesResource = void 0;
+const LOCALES_PATH = "locales";
+class LocalesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(LOCALES_PATH, options);
+    }
+    update(locales, options) {
+        return this.http.patch(LOCALES_PATH, locales, options);
+    }
+}
+exports.LocalesResource = LocalesResource;

package/dist/next/resources/localization/localizations-resource.d.ts

@@ -0,0 +1,17 @@
+import type { OvokLocalization, OvokLocalizationQuery, OvokLocalizationUpdate } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { I18nextResource } from "./i18next-resource";
+export type LocalizationList = {
+    total: number;
+    resources: OvokLocalization[];
+};
+export declare class LocalizationsResource {
+    private readonly http;
+    readonly i18next: I18nextResource;
+    constructor(http: HttpClient);
+    list(language: string, query?: OvokLocalizationQuery, options?: RequestOptions): Promise<LocalizationList>;
+    retrieve(language: string, key: string, options?: RequestOptions): Promise<OvokLocalization>;
+    update(language: string, key: string, body: OvokLocalizationUpdate, options?: RequestOptions): Promise<OvokLocalization>;
+    delete(language: string, key: string, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/localization/localizations-resource.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizationsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const i18next_resource_1 = require("./i18next-resource");
+const languagePath = (language) => `localization/${(0, url_1.pathSegment)(language)}`;
+const entryPath = (language, key) => `${languagePath(language)}/${(0, url_1.pathSegment)(key)}`;
+class LocalizationsResource {
+    constructor(http) {
+        this.http = http;
+        this.i18next = new i18next_resource_1.I18nextResource(http);
+    }
+    list(language, query = {}, options) {
+        return this.http.get(`${languagePath(language)}${(0, query_string_1.toQueryString)(query)}`, options);
+    }
+    retrieve(language, key, options) {
+        return this.http.get(entryPath(language, key), options);
+    }
+    update(language, key, body, options) {
+        return this.http.put(entryPath(language, key), body, options);
+    }
+    delete(language, key, options) {
+        return this.http.delete(entryPath(language, key), options);
+    }
+}
+exports.LocalizationsResource = LocalizationsResource;

package/dist/next/resources/measurements/measurements-resource.d.ts

@@ -0,0 +1,42 @@
+import type { GetLatestObservationsByCodeParams } from "../../../client/observation/types/GetLatestObservationsByCodeParams";
+import type { Bundle, Observation } from "@medplum/fhirtypes";
+import { observationCodesForTypes } from "../../../client/observation/methods/observationsToMeasurements";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { FhirResource } from "../fhir-resource";
+import { BuildObservationsParams } from "./observation-builder";
+import { SessionSource } from "./signed-in-account";
+export type SaveObservationsOptions = RequestOptions & {
+    /** Identifier systems that name a reading for good; the SDK's device-reading id always counts. */
+    identifierSystems?: readonly string[];
+    /** Write over the observation saved under the same reading identifiers, for a value that changes. */
+    replace?: boolean;
+};
+export type SaveObservationsResult = {
+    status: "saved";
+    response: Bundle;
+};
+export type LatestObservationsParams = GetLatestObservationsByCodeParams;
+export type LastObservationsQuery = {
+    code: string;
+    max?: number;
+};
+export type MeasurementCodeTypes = Parameters<typeof observationCodesForTypes>[0];
+export declare class MeasurementsResource {
+    private readonly http;
+    private readonly fhir;
+    private readonly account;
+    constructor(http: HttpClient, fhir: FhirResource, session: SessionSource | null);
+    save(params: BuildObservationsParams, options?: SaveObservationsOptions): Promise<SaveObservationsResult>;
+    /** One reading, main observation first, created conditionally so a retry cannot duplicate it. */
+    saveObservations(observations: Observation[], options?: SaveObservationsOptions): Promise<SaveObservationsResult>;
+    build(params: BuildObservationsParams): Promise<Observation[]>;
+    latest(params: LatestObservationsParams, options?: RequestOptions): Promise<Bundle<Observation>>;
+    lastForPatient(patientId: string, query: LastObservationsQuery, options?: RequestOptions): Promise<Bundle<Observation>>;
+    /** The comma-joined codes the types are saved under, as `latest` and FHIR `code` searches take them. */
+    codesFor(types: MeasurementCodeTypes): string;
+    private latestPatientId;
+    /** A reading split over several requests stops once another account signs in, so none of it lands elsewhere. */
+    private send;
+    private requireOwner;
+}

package/dist/next/resources/measurements/measurements-resource.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasurementsResource = void 0;
+const observationsToMeasurements_1 = require("../../../client/observation/methods/observationsToMeasurements");
+const observation_bundle_utils_1 = require("../../../client/observation/observation-bundle-utils");
+const offline_measurement_queue_1 = require("../../../client/offline/offline-measurement-queue");
+const query_string_1 = require("../../../client/query-string");
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const url_1 = require("../../http/url");
+const observation_builder_1 = require("./observation-builder");
+const save_error_1 = require("./save-error");
+const signed_in_account_1 = require("./signed-in-account");
+const LATEST_OBSERVATIONS_PATH = "fhir/Observation/$lastn";
+const LATEST_PER_CODE = 1;
+class MeasurementsResource {
+    constructor(http, fhir, session) {
+        this.http = http;
+        this.fhir = fhir;
+        this.account = new signed_in_account_1.SignedInAccount(session);
+    }
+    async save(params, options) {
+        return this.saveObservations(await this.build(params), options);
+    }
+    /** One reading, main observation first, created conditionally so a retry cannot duplicate it. */
+    async saveObservations(observations, options = {}) {
+        const { identifierSystems, replace, ...requestOptions } = options;
+        const entry = (0, observation_bundle_utils_1.linkObservationMembers)(observations).map((observation) => (0, offline_measurement_queue_1.entryForObservation)(observation, { identifierSystems, replace }));
+        const response = await this.send({ resourceType: "Bundle", type: "transaction", entry }, requestOptions);
+        return { status: "saved", response };
+    }
+    async build(params) {
+        const subject = params.patientId ? `Patient/${params.patientId}` : await this.account.profileReference();
+        return (0, observation_builder_1.buildObservations)(params, subject);
+    }
+    async latest(params, options) {
+        const query = (0, query_string_1.toQueryString)({
+            max: LATEST_PER_CODE,
+            code: params.codes,
+            patient: `Patient/${await this.latestPatientId(params)}`,
+            date: params.date ? `ge${params.date}` : undefined,
+        });
+        return this.http.get(`${LATEST_OBSERVATIONS_PATH}${query}`, options);
+    }
+    lastForPatient(patientId, query, options) {
+        return this.http.get(`patient/${(0, url_1.pathSegment)(patientId)}/observation${(0, query_string_1.toQueryString)(query)}`, options);
+    }
+    /** The comma-joined codes the types are saved under, as `latest` and FHIR `code` searches take them. */
+    codesFor(types) {
+        return (0, observationsToMeasurements_1.observationCodesForTypes)(types);
+    }
+    async latestPatientId(params) {
+        if (params.me) {
+            return idOf(await this.account.profileReference());
+        }
+        return params.patientId;
+    }
+    /** A reading split over several requests stops once another account signs in, so none of it lands elsewhere. */
+    async send(bundle, options) {
+        const owner = await this.account.key();
+        try {
+            return await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, async (request) => {
+                await this.requireOwner(owner);
+                return this.fhir.batch(request, options);
+            });
+        }
+        catch (error) {
+            throw (0, save_error_1.isBundle)(error) ? (0, save_error_1.saveErrorFrom)(error) : error;
+        }
+    }
+    async requireOwner(owner) {
+        if (owner !== (await this.account.key())) {
+            throw new ovok_errors_1.OvokConflictError((0, ovok_errors_1.detailsFor)("The signed-in account changed during the save; the rest was not sent."));
+        }
+    }
+}
+exports.MeasurementsResource = MeasurementsResource;
+const idOf = (reference) => reference.slice(reference.indexOf("/") + 1);

package/dist/next/resources/measurements/observation-builder.d.ts

@@ -0,0 +1,5 @@
+import type { GenerateObservationBodyParams } from "../../../client/observation/types/generate-observation-body/GenerateObservationBodyParams";
+import type { Observation } from "@medplum/fhirtypes";
+export type BuildObservationsParams = GenerateObservationBodyParams;
+/** One measurement's Observations about `subject`, a reference such as `Patient/1`. */
+export declare function buildObservations(params: BuildObservationsParams, subject: string): Observation[];

package/dist/next/resources/measurements/observation-builder.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObservations = buildObservations;
+const fhir_systems_1 = require("../../../client/observation/fhir-systems");
+const creator_1 = require("../../../client/observation/services/creator");
+const getDeviceObject_1 = require("../../../client/observation/utils/getDeviceObject");
+/** One measurement's Observations about `subject`, a reference such as `Patient/1`. */
+function buildObservations(params, subject) {
+    const service = creator_1.ObservationServiceCreator.getInstance().getService(params.measurement.measurementTypeKey);
+    const device = (0, getDeviceObject_1.getDeviceObject)(params.device);
+    const observations = fragmentsOf(service, params.measurement)
+        .map((fragment) => observationOf(fragment, subject, device))
+        .filter(hasValue)
+        .map((observation) => datedAt(observation, params.effectiveDateTime));
+    return params.sourceId ? namedAfterSource(observations, subject, params.sourceId) : observations;
+}
+/** Services without fragments describe their observations as parallel code, value and property lists. */
+const fragmentsOf = (service, measurement) => { var _a, _b; return (_b = (_a = service.generateObservationFragments) === null || _a === void 0 ? void 0 : _a.call(service, measurement)) !== null && _b !== void 0 ? _b : codeValueFragments(service, measurement); };
+const codeValueFragments = (service, measurement) => {
+    const values = service.generateValues(measurement);
+    const additionalProperties = service.getAdditionalProperties(measurement);
+    return service.getObservationCodes().map((code, index) => ({
+        code,
+        value: values[index],
+        additionalProperties: additionalProperties[index],
+    }));
+};
+const observationOf = (fragment, subject, device) => ({
+    resourceType: "Observation",
+    status: "registered",
+    subject: { reference: subject },
+    device,
+    ...fragment.value,
+    code: fragment.code,
+    ...fragment.additionalProperties,
+});
+const hasValue = (observation) => {
+    var _a, _b, _c, _d, _e, _f;
+    return ((_a = observation.valueQuantity) === null || _a === void 0 ? void 0 : _a.value) !== undefined ||
+        Boolean((_b = observation.valueSampledData) === null || _b === void 0 ? void 0 : _b.data) ||
+        Boolean((_e = (_d = (_c = observation.valueCodeableConcept) === null || _c === void 0 ? void 0 : _c.coding) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.code) ||
+        Boolean((_f = observation.component) === null || _f === void 0 ? void 0 : _f.length);
+};
+/** A period the service set wins over the measurement's time. */
+const datedAt = (observation, effectiveDateTime) => effectiveDateTime && !observation.effectivePeriod
+    ? { ...observation, effectiveDateTime: effectiveDateTime.toISOString() }
+    : observation;
+const namedAfterSource = (observations, subject, sourceId) => observations.map((observation, index) => {
+    var _a;
+    return ({
+        ...observation,
+        identifier: [
+            ...((_a = observation.identifier) !== null && _a !== void 0 ? _a : []),
+            { system: fhir_systems_1.DEVICE_READING_IDENTIFIER_SYSTEM, value: `${subject}/${sourceId}/${index}` },
+        ],
+    });
+});

package/dist/next/resources/measurements/save-error.d.ts

@@ -0,0 +1,5 @@
+import type { Bundle } from "@medplum/fhirtypes";
+import { OvokError } from "../../errors/ovok-errors";
+export declare const isBundle: (value: unknown) => value is Bundle;
+/** A save's response that refused or left out an observation; a refused one gives its own status. */
+export declare function saveErrorFrom(response: Bundle): OvokError;

package/dist/next/resources/measurements/save-error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBundle = void 0;
+exports.saveErrorFrom = saveErrorFrom;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const FAILED_STATUS = /^[45]/;
+const isBundle = (value) => typeof value === "object" && value !== null && value.resourceType === "Bundle";
+exports.isBundle = isBundle;
+/** A save's response that refused or left out an observation; a refused one gives its own status. */
+function saveErrorFrom(response) {
+    var _a;
+    const statuses = ((_a = response.entry) !== null && _a !== void 0 ? _a : []).map((entry) => { var _a, _b; return (_b = (_a = entry.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : ""; });
+    const refused = statuses.find((status) => FAILED_STATUS.test(status));
+    const message = refused
+        ? `The server refused an observation of the reading: ${refused}.`
+        : "The server's response left out an observation of the reading.";
+    return (0, ovok_errors_1.errorForStatus)({ ...(0, ovok_errors_1.detailsFor)(message), status: refused ? Number.parseInt(refused, 10) : null });
+}

package/dist/next/resources/measurements/signed-in-account.d.ts

@@ -0,0 +1,11 @@
+import { UserSession } from "../../auth/user-session";
+export type SessionSource = Pick<UserSession, "current">;
+/** The account a measurement belongs to; a machine client has none. */
+export declare class SignedInAccount {
+    private readonly session;
+    constructor(session: SessionSource | null);
+    /** The project and profile signed in now, or null when no one is. */
+    key(): Promise<string | null>;
+    profileReference(): Promise<string>;
+    private current;
+}

package/dist/next/resources/measurements/signed-in-account.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignedInAccount = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+/** The account a measurement belongs to; a machine client has none. */
+class SignedInAccount {
+    constructor(session) {
+        this.session = session;
+    }
+    /** The project and profile signed in now, or null when no one is. */
+    async key() {
+        const session = await this.current();
+        return session === null ? null : `${session.project.reference}|${session.profile.reference}`;
+    }
+    async profileReference() {
+        const session = await this.current();
+        if (session === null) {
+            throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)("No user is signed in; name the patient instead."));
+        }
+        return session.profile.reference;
+    }
+    async current() {
+        return this.session === null ? null : this.session.current();
+    }
+}
+exports.SignedInAccount = SignedInAccount;

package/dist/next/resources/patient/fhir-records.d.ts

@@ -0,0 +1,19 @@
+import type { Appointment, ExtractResource, ResourceType } from "@medplum/fhirtypes";
+import { RequestOptions } from "../../http/transmit";
+import { QueryParams } from "../../http/url";
+import { FhirResource } from "../fhir-resource";
+/** Lists resolve to the first page's resources, as the Medplum client's `searchResources` did. */
+export declare class FhirListResource<K extends ResourceType> {
+    protected readonly fhir: FhirResource;
+    protected readonly type: K;
+    constructor(fhir: FhirResource, type: K);
+    list(params?: QueryParams, options?: RequestOptions): Promise<ExtractResource<K>[]>;
+}
+export declare class FhirRecordsResource<K extends ResourceType> extends FhirListResource<K> {
+    retrieve(id: string, options?: RequestOptions): Promise<ExtractResource<K>>;
+}
+export declare class AppointmentsResource extends FhirRecordsResource<"Appointment"> {
+    constructor(fhir: FhirResource);
+    create(appointment: Appointment, options?: RequestOptions): Promise<Appointment>;
+    update(id: string, appointment: Appointment, options?: RequestOptions): Promise<Appointment>;
+}

package/dist/next/resources/patient/fhir-records.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentsResource = exports.FhirRecordsResource = exports.FhirListResource = void 0;
+/** Lists resolve to the first page's resources, as the Medplum client's `searchResources` did. */
+class FhirListResource {
+    constructor(fhir, type) {
+        this.fhir = fhir;
+        this.type = type;
+    }
+    async list(params = {}, options) {
+        const page = await this.fhir.search(this.type, params, options);
+        return page.data;
+    }
+}
+exports.FhirListResource = FhirListResource;
+class FhirRecordsResource extends FhirListResource {
+    retrieve(id, options) {
+        return this.fhir.read(this.type, id, options);
+    }
+}
+exports.FhirRecordsResource = FhirRecordsResource;
+class AppointmentsResource extends FhirRecordsResource {
+    constructor(fhir) {
+        super(fhir, "Appointment");
+    }
+    create(appointment, options) {
+        return this.fhir.create(appointment, options);
+    }
+    update(id, appointment, options) {
+        return this.fhir.update({ ...appointment, id }, options);
+    }
+}
+exports.AppointmentsResource = AppointmentsResource;

package/dist/next/resources/patient/patient-resource.d.ts

@@ -0,0 +1,21 @@
+import type { OvokPatientDashboard, OvokPatientDashboardQuery, OvokPatientLatestObservationsQuery, OvokPatientObservationBundle } from "../../../client/patient/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { FhirResource } from "../fhir-resource";
+import { AppointmentsResource, FhirListResource, FhirRecordsResource } from "./fhir-records";
+export declare class PatientResource {
+    private readonly http;
+    readonly appointments: AppointmentsResource;
+    readonly schedules: FhirListResource<"Schedule">;
+    readonly slots: FhirListResource<"Slot">;
+    readonly measurements: FhirRecordsResource<"Observation">;
+    readonly carePlans: FhirRecordsResource<"CarePlan">;
+    readonly questionnaires: FhirRecordsResource<"Questionnaire">;
+    readonly questionnaireResponses: FhirRecordsResource<"QuestionnaireResponse">;
+    readonly devices: FhirRecordsResource<"Device">;
+    readonly notifications: FhirRecordsResource<"CommunicationRequest">;
+    constructor(http: HttpClient, fhir: FhirResource);
+    latestObservations(params?: OvokPatientLatestObservationsQuery, options?: RequestOptions): Promise<OvokPatientObservationBundle>;
+    /** Every read is scoped to the signed-in patient unless its query names another. */
+    dashboard(params?: OvokPatientDashboardQuery, options?: RequestOptions): Promise<OvokPatientDashboard>;
+}

package/dist/next/resources/patient/patient-resource.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatientResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const auth_resource_1 = require("../auth-resource");
+const fhir_records_1 = require("./fhir-records");
+const LATEST_OBSERVATIONS_PATH = "fhir/Observation/$lastn";
+class PatientResource {
+    constructor(http, fhir) {
+        this.http = http;
+        this.appointments = new fhir_records_1.AppointmentsResource(fhir);
+        this.schedules = new fhir_records_1.FhirListResource(fhir, "Schedule");
+        this.slots = new fhir_records_1.FhirListResource(fhir, "Slot");
+        this.measurements = new fhir_records_1.FhirRecordsResource(fhir, "Observation");
+        this.carePlans = new fhir_records_1.FhirRecordsResource(fhir, "CarePlan");
+        this.questionnaires = new fhir_records_1.FhirRecordsResource(fhir, "Questionnaire");
+        this.questionnaireResponses = new fhir_records_1.FhirRecordsResource(fhir, "QuestionnaireResponse");
+        this.devices = new fhir_records_1.FhirRecordsResource(fhir, "Device");
+        this.notifications = new fhir_records_1.FhirRecordsResource(fhir, "CommunicationRequest");
+    }
+    latestObservations(params = {}, options) {
+        const { patient, max, code } = params;
+        return this.http.get(`${LATEST_OBSERVATIONS_PATH}${(0, query_string_1.toQueryString)({ patient, max, code })}`, options);
+    }
+    /** Every read is scoped to the signed-in patient unless its query names another. */
+    async dashboard(params = {}, options) {
+        const profile = await this.http.get(auth_resource_1.ME_PATH, options);
+        const patient = `Patient/${profile.profile.id}`;
+        const latestObservations = await this.latestObservations(withPatient(params.latestObservations, patient), options);
+        const [measurementHistory, carePlans] = await Promise.all([
+            this.measurements.list(withPatient(params.measurementHistory, patient), options),
+            this.carePlans.list(withPatient(params.carePlans, patient), options),
+        ]);
+        return { carePlans, latestObservations, measurementHistory, profile };
+    }
+}
+exports.PatientResource = PatientResource;
+const withPatient = (query, patient) => { var _a; return ({ ...query, patient: (_a = query === null || query === void 0 ? void 0 : query.patient) !== null && _a !== void 0 ? _a : patient }); };

package/dist/next/resources/projects/project-features-resource.d.ts

@@ -0,0 +1,9 @@
+import type { OvokProjectFeature, OvokProjectFeatures } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class ProjectFeaturesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(options?: RequestOptions): Promise<OvokProjectFeatures>;
+    update(features: OvokProjectFeature[], options?: RequestOptions): Promise<OvokProjectFeatures>;
+}

package/dist/next/resources/projects/project-features-resource.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectFeaturesResource = void 0;
+const FEATURES_PATH = "v1/projects/me/features";
+class ProjectFeaturesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(FEATURES_PATH, options);
+    }
+    update(features, options) {
+        const body = { features };
+        return this.http.patch(FEATURES_PATH, body, options);
+    }
+}
+exports.ProjectFeaturesResource = ProjectFeaturesResource;

package/dist/next/resources/projects/project-members-resource.d.ts

@@ -0,0 +1,19 @@
+import type { OvokInviteProjectMember, OvokProjectMember, OvokProjectMemberResponse, OvokRemoveProjectMemberResponse, OvokUpdateProjectMember } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+export type ProjectMemberListQuery = {
+    accessPolicyId?: string;
+    profileId?: string;
+    userId?: string;
+    page?: number;
+    count?: number;
+};
+export declare class ProjectMembersResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(query?: ProjectMemberListQuery, options?: RequestOptions): PagePromise<OvokProjectMember>;
+    invite(body: OvokInviteProjectMember, options?: RequestOptions): Promise<OvokProjectMemberResponse>;
+    update(membershipId: string, body: OvokUpdateProjectMember, options?: RequestOptions): Promise<OvokProjectMemberResponse>;
+    remove(membershipId: string, options?: RequestOptions): Promise<OvokRemoveProjectMemberResponse>;
+}

package/dist/next/resources/projects/project-members-resource.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectMembersResource = void 0;
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const MEMBERS_PATH = "v1/projects/me/members";
+const memberPath = (membershipId) => `${MEMBERS_PATH}/${(0, url_1.pathSegment)(membershipId)}`;
+class ProjectMembersResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(query = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), MEMBERS_PATH, query);
+    }
+    invite(body, options) {
+        return this.http.post(MEMBERS_PATH, body, options);
+    }
+    update(membershipId, body, options) {
+        return this.http.patch(memberPath(membershipId), body, options);
+    }
+    remove(membershipId, options) {
+        return this.http.delete(memberPath(membershipId), options);
+    }
+}
+exports.ProjectMembersResource = ProjectMembersResource;

package/dist/next/resources/projects/project-settings-resource.d.ts

@@ -0,0 +1,10 @@
+import type { OvokProjectSettingKey, OvokProjectSettings, OvokProjectTextSettingKey } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class ProjectSettingsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(options?: RequestOptions): Promise<OvokProjectSettings>;
+    update(key: OvokProjectSettingKey, enabled: boolean, options?: RequestOptions): Promise<OvokProjectSettings>;
+    updateText(key: OvokProjectTextSettingKey, value: string | null, options?: RequestOptions): Promise<OvokProjectSettings>;
+}

package/dist/next/resources/projects/project-settings-resource.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectSettingsResource = void 0;
+const url_1 = require("../../http/url");
+const SETTINGS_PATH = "v1/project/settings";
+const TEXT_SETTINGS_PATH = `${SETTINGS_PATH}/values`;
+class ProjectSettingsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(SETTINGS_PATH, options);
+    }
+    update(key, enabled, options) {
+        return this.http.put(`${SETTINGS_PATH}/${(0, url_1.pathSegment)(key)}`, { enabled }, options);
+    }
+    updateText(key, value, options) {
+        return this.http.put(`${TEXT_SETTINGS_PATH}/${(0, url_1.pathSegment)(key)}`, { value }, options);
+    }
+}
+exports.ProjectSettingsResource = ProjectSettingsResource;

package/dist/next/resources/projects/projects-resource.d.ts

@@ -0,0 +1,20 @@
+import type { OvokAdministeredProject } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { ProjectFeaturesResource } from "./project-features-resource";
+import { ProjectMembersResource } from "./project-members-resource";
+import { ProjectSettingsResource } from "./project-settings-resource";
+export type ProjectListQuery = {
+    page?: number;
+    count?: number;
+};
+export declare class ProjectsResource {
+    private readonly http;
+    readonly members: ProjectMembersResource;
+    readonly features: ProjectFeaturesResource;
+    readonly settings: ProjectSettingsResource;
+    constructor(http: HttpClient);
+    /** The projects the caller administers, wherever they are signed in. */
+    list(query?: ProjectListQuery, options?: RequestOptions): PagePromise<OvokAdministeredProject>;
+}

package/dist/next/resources/projects/projects-resource.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectsResource = void 0;
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const project_features_resource_1 = require("./project-features-resource");
+const project_members_resource_1 = require("./project-members-resource");
+const project_settings_resource_1 = require("./project-settings-resource");
+const PROJECTS_PATH = "v1/projects";
+class ProjectsResource {
+    constructor(http) {
+        this.http = http;
+        this.members = new project_members_resource_1.ProjectMembersResource(http);
+        this.features = new project_features_resource_1.ProjectFeaturesResource(http);
+        this.settings = new project_settings_resource_1.ProjectSettingsResource(http);
+    }
+    /** The projects the caller administers, wherever they are signed in. */
+    list(query = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), PROJECTS_PATH, query);
+    }
+}
+exports.ProjectsResource = ProjectsResource;

package/dist/next/resources/questionnaires/questionnaires-resource.d.ts

@@ -0,0 +1,18 @@
+import type { Bundle, Observation, Parameters, QuestionnaireResponse } from "@medplum/fhirtypes";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { FhirResource } from "../fhir-resource";
+export declare class QuestionnairesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    populate(questionnaireId: string, parameters?: Parameters, options?: RequestOptions): Promise<Parameters>;
+}
+export declare class QuestionnaireResponsesResource {
+    private readonly http;
+    private readonly fhir;
+    constructor(http: HttpClient, fhir: FhirResource);
+    submit(response: QuestionnaireResponse, options?: RequestOptions): Promise<Bundle>;
+    /** One transaction, so the response is never saved without its observations. */
+    submitWithObservations(response: QuestionnaireResponse, observations: Observation[], options?: RequestOptions): Promise<Bundle>;
+    extract(questionnaireResponseId: string, options?: RequestOptions): Promise<Parameters>;
+}

package/dist/next/resources/questionnaires/questionnaires-resource.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionnaireResponsesResource = exports.QuestionnairesResource = void 0;
+const url_1 = require("../../http/url");
+class QuestionnairesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    populate(questionnaireId, parameters = { resourceType: "Parameters", parameter: [] }, options) {
+        return this.http.post(`fhir/Questionnaire/${(0, url_1.pathSegment)(questionnaireId)}/$populate`, parameters, options);
+    }
+}
+exports.QuestionnairesResource = QuestionnairesResource;
+class QuestionnaireResponsesResource {
+    constructor(http, fhir) {
+        this.http = http;
+        this.fhir = fhir;
+    }
+    submit(response, options) {
+        return this.submitWithObservations(response, [], options);
+    }
+    /** One transaction, so the response is never saved without its observations. */
+    submitWithObservations(response, observations, options) {
+        const entry = [createEntry(response), ...observations.map(createEntry)];
+        return this.fhir.batch({ resourceType: "Bundle", type: "transaction", entry }, options);
+    }
+    extract(questionnaireResponseId, options) {
+        return this.http.post(`fhir/QuestionnaireResponse/${(0, url_1.pathSegment)(questionnaireResponseId)}/$extract`, {}, options);
+    }
+}
+exports.QuestionnaireResponsesResource = QuestionnaireResponsesResource;
+const createEntry = (resource) => ({
+    fullUrl: resource.id,
+    request: { method: "POST", url: resource.resourceType },
+    resource,
+});