@digitalmedika/satusehat 0.1.0 → 0.3.0

package/README.md

@@ -14,9 +14,15 @@ SDK ini dirancang untuk:
 
 Helper builder yang saat ini tersedia:
 
+- `createEncounterBuilder`
+- `createEncounterConditionBuilder`
+- `createEmergencyEncounterHistory`
+- `createChestXRayStudyBuilder`
 - `createCompleteBloodCountPanelBuilder`
 - `createLaboratoryPanelBuilder`
 - `createOrganizationBuilder`
+- `createRiskAssessmentBuilder`
+- `createServiceRequestImagingStudyDiagnosticReportBuilder`
 - `createServiceRequestSpecimenObservationBuilder`
 
 ## Installation
@@ -34,13 +40,82 @@ bun install
 ## Quick Start
 
 ```ts
-import { createSatuSehatClientFromEnv } from "@digitalmedika/satusehat";
+import {
+  createEncounterBuilder,
+  createSatuSehatClientFromEnv,
+} from "@digitalmedika/satusehat";
 
 const client = createSatuSehatClientFromEnv();
 
-const patient = await client.patient.search({
+const patientResult = await client.patient.search({
   identifier: "https://fhir.kemkes.go.id/id/nik|9271060312000001",
 });
+
+const patient = patientResult.entry?.[0]?.resource;
+
+if (!patient?.id) {
+  throw new Error("Patient tidak ditemukan");
+}
+
+const encounterDraft = createEncounterBuilder({
+  preset: "outpatient",
+  identifier: {
+    system: "http://sys-ids.kemkes.go.id/encounter/10000004",
+    use: "official",
+    value: "RJ-20240001",
+  },
+  status: "arrived",
+  subject: {
+    reference: `Patient/${patient.id}`,
+    display: patient.name?.[0]?.text ?? "Pasien SATUSEHAT",
+  },
+  period: {
+    start: "2024-04-01T01:00:00+00:00",
+    end: "2024-04-01T02:00:00+00:00",
+  },
+  reasonCode: {
+    coding: [
+      {
+        system: "http://terminology.hl7.org/CodeSystem/encounter-reason",
+        code: "185349003",
+        display: "Encounter for check up",
+      },
+    ],
+  },
+  diagnosis: {
+    condition: {
+      reference: "Condition/4bbbe654-14f5-4ab3-a36e-a1e307f67bb8",
+    },
+    use: {
+      coding: [
+        {
+          system: "https://www.hl7.org/fhir/Codesystem-diagnosis-role",
+          code: "AD",
+          display: "Admission diagnosis",
+        },
+      ],
+    },
+    rank: 1,
+  },
+  location: {
+    location: {
+      reference: "Location/408ba28c-3115-4df5-85c6-60f15b44e7fa",
+      display: "Poliklinik Rawat Jalan",
+    },
+    status: "active",
+  },
+  serviceProvider: {
+    reference: "Organization/10000004",
+    display: "RS SATUSEHAT",
+  },
+}).build();
+
+const encounter = await client.encounter.create(encounterDraft);
+
+console.log({
+  patientId: patient.id,
+  encounterId: encounter.id,
+});
 ```
 
 ## Environment Variables
@@ -52,6 +127,7 @@ Variable utama:
 - `SATUSEHAT_ENV`
 - `SATUSEHAT_BASE_URL`
 - `SATUSEHAT_AUTH_BASE_URL`
+- `SATUSEHAT_DICOM_BASE_URL`
 - `SATUSEHAT_CLIENT_ID`
 - `SATUSEHAT_CLIENT_SECRET`
 - `SATUSEHAT_TOKEN_CACHE_FILE`
@@ -60,10 +136,17 @@ Variable utama:
 
 Saat ini resource yang sudah tersedia:
 
+- `allergyIntolerance`
+- `clinicalImpression`
+- `composition`
 - `condition`
+- `dicomRouter`
 - `diagnosticReport`
 - `encounter`
+- `imagingStudy`
+- `medicationAdministration`
 - `observation`
+- `nutritionOrder`
 - `procedure`
 - `medication`
 - `medicationRequest`
@@ -74,6 +157,8 @@ Saat ini resource yang sudah tersedia:
 - `location`
 - `practitioner`
 - `practitionerRole`
+- `questionnaireResponse`
+- `riskAssessment`
 
 ## Token Handling
 
@@ -106,25 +191,58 @@ Untuk environment `sandbox`, smoke test akan memakai dummy patient resmi SATUSEH
 - [Getting Started](./docs/getting-started.md)
 - [Authentication](./docs/authentication.md)
 - [Errors](./docs/errors.md)
+- [AllergyIntolerance](./docs/resources/allergy-intolerance.md)
+- [ClinicalImpression](./docs/resources/clinical-impression.md)
+- [Composition](./docs/resources/composition.md)
 - [Condition](./docs/resources/condition.md)
+- [DICOM Router](./docs/resources/dicom-router.md)
+- [QuestionnaireResponse](./docs/resources/questionnaire-response.md)
+- [RiskAssessment](./docs/resources/risk-assessment.md)
 - [DiagnosticReport](./docs/resources/diagnostic-report.md)
+- [ImagingStudy](./docs/resources/imaging-study.md)
+- [Encounter Builder](./docs/helpers/encounter-builder.md)
+- [Encounter -> Condition Builder](./docs/helpers/encounter-condition-builder.md)
 - [Patient](./docs/resources/patient.md)
 - [Encounter](./docs/resources/encounter.md)
 - [Procedure](./docs/resources/procedure.md)
 - [Observation](./docs/resources/observation.md)
+- [MedicationAdministration](./docs/resources/medication-administration.md)
+- [NutritionOrder](./docs/resources/nutrition-order.md)
 - [Medication](./docs/resources/medication.md)
 - [MedicationRequest](./docs/resources/medication-request.md)
 - [ServiceRequest](./docs/resources/service-request.md)
 - [Specimen](./docs/resources/specimen.md)
 - [ServiceRequest -> Specimen -> Observation Builder](./docs/helpers/service-request-specimen-observation-builder.md)
+- [ServiceRequest -> ImagingStudy -> DiagnosticReport Builder](./docs/helpers/service-request-imaging-study-diagnostic-report-builder.md)
+- [Chest X-Ray Study Builder](./docs/helpers/chest-xray-study-builder.md)
 - [Laboratory Panel Builder](./docs/helpers/laboratory-panel-builder.md)
 - [CBC Panel Builder](./docs/helpers/cbc-panel-builder.md)
+- [Risk Assessment Builder](./docs/helpers/risk-assessment-builder.md)
 - [Organization](./docs/resources/organization.md)
 - [Location](./docs/resources/location.md)
 - [Practitioner](./docs/resources/practitioner.md)
 - [PractitionerRole](./docs/resources/practitioner-role.md)
 - [Planning](./docs/planning.md)
 
+## DICOM Router
+
+SDK ini juga mendukung download file `docker-compose.yml` untuk DICOM Router SATUSEHAT:
+
+```ts
+const dockerCompose = await client.dicomRouter.downloadConfig();
+```
+
+Secara default SDK akan memakai endpoint berikut:
+
+- sandbox: `https://api-satusehat-stg.dto.kemkes.go.id/dicom-router`
+- production: `https://api-satusehat.kemkes.go.id/dicom-router`
+
+## Buy Us a Coffee
+
+Kalau project ini membantu, kamu bisa dukung Digital Medika lewat Saweria:
+
+- [Buy us a coffee on Saweria](https://saweria.co/digitalmedika)
+
 ## Premium Support
 
 Untuk premium support dan implementasi, hubungi:

package/dist/builders/chest-xray-study-builder.d.ts

@@ -0,0 +1,16 @@
+import { type ServiceRequestImagingStudyDiagnosticReportBuilder } from "./service-request-imaging-study-diagnostic-report-builder";
+import type { Reference } from "../schemas/common";
+import type { DiagnosticReportCreateInput } from "../schemas/diagnostic-report";
+import type { ImagingStudyCreateInput } from "../schemas/imaging-study";
+import type { ServiceRequestCreateInput } from "../schemas/service-request";
+export interface ChestXRayStudyBuilderInput {
+    subject: Reference;
+    encounter: Reference;
+    organizationId: string;
+    accessionNumber: string;
+    identifierUse?: string;
+    serviceRequest?: Partial<Omit<ServiceRequestCreateInput, "resourceType" | "subject" | "encounter" | "status" | "intent" | "code">>;
+    imagingStudy?: Partial<Omit<ImagingStudyCreateInput, "resourceType" | "subject" | "encounter" | "basedOn" | "identifier" | "status" | "modality">>;
+    diagnosticReport?: Partial<Omit<DiagnosticReportCreateInput, "resourceType" | "subject" | "encounter" | "status" | "code">>;
+}
+export declare function createChestXRayStudyBuilder(input: ChestXRayStudyBuilderInput): ServiceRequestImagingStudyDiagnosticReportBuilder;

package/dist/builders/encounter-builder.d.ts

@@ -0,0 +1,124 @@
+import type { Reference } from "../schemas/common";
+import type { EncounterAdmitSource, EncounterClass, EncounterClassHistory, EncounterCreateInput, EncounterDischargeDisposition, EncounterDiagnosis, EncounterHospitalization, EncounterIdentifier, EncounterLocation, EncounterLocationServiceClassExtension, EncounterParticipant, EncounterStatus, EncounterStatusHistory } from "../schemas/encounter";
+declare const ENCOUNTER_CLASS_PRESETS: {
+    outpatient: {
+        system: string;
+        code: string;
+        display: string;
+    };
+    inpatient: {
+        system: string;
+        code: string;
+        display: string;
+    };
+    emergency: {
+        system: string;
+        code: string;
+        display: string;
+    };
+};
+type EncounterBuilderCommonInput = {
+    identifier: EncounterIdentifier | EncounterIdentifier[];
+    status: EncounterStatus;
+    statusHistory?: EncounterStatusHistory[];
+    classHistory?: EncounterClassHistory[];
+    type?: NonNullable<EncounterCreateInput["type"]>;
+    serviceType?: EncounterCreateInput["serviceType"];
+    priority?: EncounterCreateInput["priority"];
+    subject: Reference;
+    episodeOfCare?: Reference[];
+    basedOn?: Reference[];
+    participant?: EncounterParticipant[];
+    period: EncounterCreateInput["period"];
+    length?: EncounterCreateInput["length"];
+    reasonCode: EncounterCreateInput["reasonCode"][number] | EncounterCreateInput["reasonCode"];
+    reasonReference?: Reference[];
+    diagnosis: EncounterDiagnosis | EncounterDiagnosis[];
+    account?: Reference[];
+    hospitalization?: EncounterHospitalization;
+    location: EncounterLocation | EncounterLocation[];
+    serviceProvider: Reference;
+    partOf?: Reference;
+};
+type EncounterBuilderPresetInput = EncounterBuilderCommonInput & {
+    preset: keyof typeof ENCOUNTER_CLASS_PRESETS;
+    encounterClass?: never;
+};
+type EncounterBuilderCustomClassInput = EncounterBuilderCommonInput & {
+    preset?: never;
+    encounterClass: EncounterClass;
+};
+export type EncounterBuilderPreset = keyof typeof ENCOUNTER_CLASS_PRESETS;
+export type EncounterBuilderInput = EncounterBuilderPresetInput | EncounterBuilderCustomClassInput;
+export type EncounterHospitalizationHelperInput = Omit<EncounterHospitalization, "admitSource" | "dischargeDisposition"> & {
+    admitSource?: EncounterAdmitSource | string;
+    dischargeDisposition?: EncounterDischargeDisposition | string;
+};
+export interface EmergencyEncounterStatusStageInput {
+    status: EncounterStatus;
+    start: string;
+}
+export type EmergencyEncounterClassStageInput = {
+    start: string;
+    preset: EncounterBuilderPreset;
+    encounterClass?: never;
+} | {
+    start: string;
+    preset?: never;
+    encounterClass: EncounterClass;
+};
+export interface EmergencyEncounterHistoryInput {
+    statusStages: [
+        EmergencyEncounterStatusStageInput,
+        ...EmergencyEncounterStatusStageInput[]
+    ];
+    periodEnd: string;
+    classStages?: [
+        EmergencyEncounterClassStageInput,
+        ...EmergencyEncounterClassStageInput[]
+    ];
+}
+export interface EmergencyEncounterHistoryResult {
+    status: EncounterStatus;
+    period: EncounterCreateInput["period"];
+    encounterClass: EncounterClass;
+    statusHistory: EncounterStatusHistory[];
+    classHistory: EncounterClassHistory[];
+}
+export declare function createEncounterHospitalization(input: EncounterHospitalizationHelperInput): EncounterHospitalization;
+export declare function createEmergencyEncounterHistory(input: EmergencyEncounterHistoryInput): EmergencyEncounterHistoryResult;
+export declare function createEncounterLocationServiceClassExtension(valueCode: string): EncounterLocationServiceClassExtension;
+export declare function withEncounterLocationServiceClass(location: EncounterLocation, valueCode: string): EncounterLocation;
+export declare class EncounterBuilder {
+    private draft;
+    constructor(input: EncounterBuilderInput);
+    addAccount(reference: Reference): this;
+    addBasedOn(reference: Reference): this;
+    addDiagnosis(diagnosis: EncounterDiagnosis): this;
+    addEpisodeOfCare(reference: Reference): this;
+    addIdentifier(identifier: EncounterIdentifier): this;
+    addLocation(location: EncounterLocation): this;
+    addParticipant(participant: EncounterParticipant): this;
+    addReasonCode(reasonCode: EncounterCreateInput["reasonCode"][number]): this;
+    addReasonReference(reference: Reference): this;
+    addStatusHistory(statusHistory: EncounterStatusHistory): this;
+    addClassHistory(classHistory: EncounterClassHistory): this;
+    addType(type: NonNullable<EncounterCreateInput["type"]>[number]): this;
+    merge(input: Partial<Omit<EncounterCreateInput, "resourceType">>): this;
+    setClass(value: EncounterClass): this;
+    setHospitalization(value: EncounterHospitalization): this;
+    setInpatientHospitalization(input: EncounterHospitalizationHelperInput): this;
+    setLength(value: NonNullable<EncounterCreateInput["length"]>): this;
+    setPartOf(reference: Reference): this;
+    setPeriod(value: EncounterCreateInput["period"]): this;
+    setPreset(preset: EncounterBuilderPreset): this;
+    setPriority(value: NonNullable<EncounterCreateInput["priority"]>): this;
+    setServiceProvider(reference: Reference): this;
+    setServiceType(value: NonNullable<EncounterCreateInput["serviceType"]>): this;
+    setLocationServiceClass(locationIndex: number, valueCode: string): this;
+    setStatus(value: EncounterStatus): this;
+    setSubject(reference: Reference): this;
+    build(): EncounterCreateInput;
+}
+export declare function createEncounterBuilder(input: EncounterBuilderInput): EncounterBuilder;
+export {};

package/dist/builders/encounter-condition-builder.d.ts

@@ -0,0 +1,28 @@
+import type { Reference } from "../schemas/common";
+import type { ConditionCreateInput, ConditionNote } from "../schemas/condition";
+import type { EncounterDiagnosis } from "../schemas/encounter";
+type ConditionMutableInput = Partial<Omit<ConditionCreateInput, "resourceType" | "subject" | "encounter">>;
+export interface EncounterConditionBuilderInput {
+    subject: Reference;
+    encounter: Reference;
+    condition: Pick<ConditionCreateInput, "code"> & ConditionMutableInput;
+}
+export interface EncounterDiagnosisBuildLinks {
+    conditionId?: string;
+    conditionReference?: Reference;
+    use?: EncounterDiagnosis["use"];
+    rank?: number;
+}
+export declare class EncounterConditionBuilder {
+    private conditionDraft;
+    constructor(input: EncounterConditionBuilderInput);
+    setSubject(subject: Reference): this;
+    setEncounter(encounter: Reference): this;
+    mergeCondition(input: ConditionMutableInput): this;
+    addCategory(category: NonNullable<ConditionCreateInput["category"]>[number]): this;
+    addNote(note: ConditionNote): this;
+    buildCondition(): ConditionCreateInput;
+    buildEncounterDiagnosis(links?: EncounterDiagnosisBuildLinks): EncounterDiagnosis;
+}
+export declare function createEncounterConditionBuilder(input: EncounterConditionBuilderInput): EncounterConditionBuilder;
+export {};

package/dist/builders/risk-assessment-builder.d.ts

@@ -0,0 +1,39 @@
+import type { Reference } from "../schemas/common";
+import type { RiskAssessmentCreateInput, RiskAssessmentNote, RiskAssessmentPrediction, RiskAssessmentStatus } from "../schemas/risk-assessment";
+export interface RiskAssessmentBuilderInput {
+    subject: Reference;
+    status: RiskAssessmentStatus;
+    code?: RiskAssessmentCreateInput["code"];
+    encounter?: Reference;
+    occurrenceDateTime?: string;
+    performer?: Reference;
+    condition?: Reference;
+    reasonCode?: RiskAssessmentCreateInput["reasonCode"];
+    reasonReference?: Reference;
+    method?: RiskAssessmentCreateInput["method"];
+    mitigation?: string;
+}
+export declare class RiskAssessmentBuilder {
+    private draft;
+    constructor(input: RiskAssessmentBuilderInput);
+    addBasis(reference: Reference): this;
+    addIdentifier(identifier: NonNullable<RiskAssessmentCreateInput["identifier"]>[number]): this;
+    addNote(note: RiskAssessmentNote): this;
+    addPrediction(prediction: RiskAssessmentPrediction): this;
+    merge(input: Partial<Omit<RiskAssessmentCreateInput, "resourceType">>): this;
+    setBasedOn(reference: Reference): this;
+    setCode(code: NonNullable<RiskAssessmentCreateInput["code"]>): this;
+    setCondition(reference: Reference): this;
+    setEncounter(reference: Reference): this;
+    setMethod(method: NonNullable<RiskAssessmentCreateInput["method"]>): this;
+    setMitigation(mitigation: string): this;
+    setOccurrenceDateTime(value: string): this;
+    setOccurrencePeriod(value: NonNullable<RiskAssessmentCreateInput["occurrencePeriod"]>): this;
+    setPerformer(reference: Reference): this;
+    setReasonCode(reasonCode: NonNullable<RiskAssessmentCreateInput["reasonCode"]>): this;
+    setReasonReference(reference: Reference): this;
+    setStatus(status: RiskAssessmentStatus): this;
+    setSubject(reference: Reference): this;
+    build(): RiskAssessmentCreateInput;
+}
+export declare function createRiskAssessmentBuilder(input: RiskAssessmentBuilderInput): RiskAssessmentBuilder;

package/dist/builders/service-request-imaging-study-diagnostic-report-builder.d.ts

@@ -0,0 +1,49 @@
+import type { Reference } from "../schemas/common";
+import type { DiagnosticReportCreateInput, DiagnosticReportMedia } from "../schemas/diagnostic-report";
+import type { ImagingStudyCreateInput, ImagingStudyNote, ImagingStudySeries } from "../schemas/imaging-study";
+import type { ServiceRequestCreateInput, ServiceRequestNote } from "../schemas/service-request";
+export interface ServiceRequestImagingStudyDiagnosticReportBuilderInput {
+    subject: Reference;
+    encounter: Reference;
+    serviceRequest: Pick<ServiceRequestCreateInput, "status" | "intent" | "code"> & Partial<Omit<ServiceRequestCreateInput, "resourceType" | "subject" | "encounter">>;
+    imagingStudy: Pick<ImagingStudyCreateInput, "identifier" | "status" | "modality"> & Partial<Omit<ImagingStudyCreateInput, "resourceType" | "subject" | "encounter" | "basedOn">>;
+    diagnosticReport: Pick<DiagnosticReportCreateInput, "status" | "code"> & Partial<Omit<DiagnosticReportCreateInput, "resourceType" | "subject" | "encounter">>;
+}
+export interface RadiologyServiceRequestBuildLinks {
+    serviceRequestId?: string;
+    serviceRequestReference?: Reference;
+}
+export interface RadiologyImagingStudyBuildLinks extends RadiologyServiceRequestBuildLinks {
+}
+export interface RadiologyDiagnosticReportBuildLinks extends RadiologyServiceRequestBuildLinks {
+    imagingStudyId?: string;
+    imagingStudyIds?: string[];
+    imagingStudyReference?: Reference;
+    imagingStudyReferences?: Reference[];
+}
+type ServiceRequestMutableInput = Partial<Omit<ServiceRequestCreateInput, "resourceType" | "subject" | "encounter">>;
+type ImagingStudyDraftInput = Pick<ImagingStudyCreateInput, "identifier" | "status" | "modality"> & Partial<Omit<ImagingStudyCreateInput, "resourceType" | "subject" | "encounter" | "basedOn">>;
+type ImagingStudyMutableInput = Partial<Omit<ImagingStudyDraftInput, "identifier" | "status" | "modality">> & Partial<Pick<ImagingStudyDraftInput, "identifier" | "status" | "modality">>;
+type DiagnosticReportMutableInput = Partial<Omit<DiagnosticReportCreateInput, "resourceType" | "subject" | "encounter">>;
+export declare class ServiceRequestImagingStudyDiagnosticReportBuilder {
+    private serviceRequestDraft;
+    private imagingStudyDraft;
+    private diagnosticReportDraft;
+    private subject;
+    private encounter;
+    constructor(input: ServiceRequestImagingStudyDiagnosticReportBuilderInput);
+    setSubject(subject: Reference): this;
+    setEncounter(encounter: Reference): this;
+    mergeServiceRequest(input: ServiceRequestMutableInput): this;
+    mergeImagingStudy(input: ImagingStudyMutableInput): this;
+    mergeDiagnosticReport(input: DiagnosticReportMutableInput): this;
+    addServiceRequestNote(note: ServiceRequestNote): this;
+    addImagingStudyNote(note: ImagingStudyNote): this;
+    addImagingStudySeries(series: ImagingStudySeries): this;
+    addDiagnosticReportMedia(media: DiagnosticReportMedia): this;
+    buildServiceRequest(): ServiceRequestCreateInput;
+    buildImagingStudy(links?: RadiologyImagingStudyBuildLinks): ImagingStudyCreateInput;
+    buildDiagnosticReport(links?: RadiologyDiagnosticReportBuildLinks): DiagnosticReportCreateInput;
+}
+export declare function createServiceRequestImagingStudyDiagnosticReportBuilder(input: ServiceRequestImagingStudyDiagnosticReportBuilderInput): ServiceRequestImagingStudyDiagnosticReportBuilder;
+export {};

package/dist/client/create-client.d.ts

@@ -3,3 +3,4 @@ export declare function createSatuSehatClient(config?: SatuSehatClientConfig): S
 export declare function createSatuSehatClientFromEnv(env?: SatuSehatEnvSource, overrides?: Omit<SatuSehatClientConfig, "environment" | "baseUrl" | "authBaseUrl" | "credentials">): SatuSehatClient;
 export declare function resolveSatuSehatBaseUrl(environment: SatuSehatEnvironment): string;
 export declare function resolveSatuSehatAuthBaseUrl(environment: SatuSehatEnvironment): string;
+export declare function resolveSatuSehatDicomBaseUrl(environment: SatuSehatEnvironment): string;

package/dist/client/transport.d.ts

@@ -20,8 +20,17 @@ export interface RequestOptions<TQuerySchema extends ZodTypeAny | undefined, TBo
     signal?: AbortSignal;
     responseSchema: TResponseSchema;
 }
+export interface TextRequestOptions<TQuerySchema extends ZodTypeAny | undefined> {
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    query?: unknown;
+    querySchema?: TQuerySchema;
+    headers?: HeadersInit;
+    signal?: AbortSignal;
+}
 export interface Transport {
     request<TQuerySchema extends ZodTypeAny | undefined, TBodySchema extends ZodTypeAny | undefined, TResponseSchema extends ZodTypeAny>(options: RequestOptions<TQuerySchema, TBodySchema, TResponseSchema>): Promise<InferSchema<TResponseSchema>>;
+    requestText<TQuerySchema extends ZodTypeAny | undefined>(options: TextRequestOptions<TQuerySchema>): Promise<string>;
 }
 type InferSchema<TSchema extends ZodTypeAny> = TSchema["_output"];
 export declare function createTransport(options: TransportOptions): Transport;