fhir - v0.8.0

fhir/r4/sansio

https://hl7.org/fhir/r4 r4 sans-io request/response helpers suitable for building clients on top of, such as fhirclient_httpc.gleam and fhirclient_rsvp.gleam

Types

ErrBaseUrl

</>

a problem with your baseurl in fhirclient_new(baseurl), which you should only see if you have typo in server base url

pub type ErrBaseUrl {
  UriParseFail
  UriNoHttpOrHttps
  UriNoHost
}

Constructors 

  • UriParseFail
  • UriNoHttpOrHttps
  • UriNoHost

ErrReq

</> 
pub type ErrReq {
  ErrNoId
}

Constructors 

  • ErrNoId

    could not make an update request because resource has no id

ErrResp

</> 
pub type ErrResp {
  ErrParseJson(json.DecodeError)
  ErrNotJson(response.Response(String))
  ErrOperationoutcome(resources.Operationoutcome)
}

Constructors 

  • ErrParseJson(json.DecodeError)

    got json but could not parse it, probably a missing required field

  • ErrNotJson(response.Response(String))

    did not get resource json, often server eg nginx gives basic html response

  • ErrOperationoutcome(resources.Operationoutcome)

    got operationoutcome error from fhir server

FhirClient

</>

FHIR client for sending http requests to server such as let pat = resources.patient_read("123", client)

create client from server base url with fhirclient_new(baseurl)`

let assert Ok(client) = sansio.fhirclient_new("r4.smarthealthit.org/")

let assert Ok(client) = sansio.fhirclient_new("https://r4.smarthealthit.org/")

let assert Ok(client) = sansio.fhirclient_new("https://hapi.fhir.org/baser4")

let assert Ok(client) = sansio.fhirclient_new("127.0.0.1:8000")

pub type FhirClient {
  FhirClient(
    baseurl: uri.Uri,
    basereq: request.Request(option.Option(json.Json)),
    print_sent_requests: Logging,
    print_received_responses: Logging,
  )
}

Constructors

GroupedResources

</> 
pub type GroupedResources {
  GroupedResources(
    account: List(resources.Account),
    activitydefinition: List(resources.Activitydefinition),
    adverseevent: List(resources.Adverseevent),
    allergyintolerance: List(resources.Allergyintolerance),
    appointment: List(resources.Appointment),
    appointmentresponse: List(resources.Appointmentresponse),
    auditevent: List(resources.Auditevent),
    basic: List(resources.Basic),
    binary: List(resources.Binary),
    biologicallyderivedproduct: List(
      resources.Biologicallyderivedproduct,
    ),
    bodystructure: List(resources.Bodystructure),
    bundle: List(resources.Bundle),
    capabilitystatement: List(resources.Capabilitystatement),
    careplan: List(resources.Careplan),
    careteam: List(resources.Careteam),
    catalogentry: List(resources.Catalogentry),
    chargeitem: List(resources.Chargeitem),
    chargeitemdefinition: List(resources.Chargeitemdefinition),
    claim: List(resources.Claim),
    claimresponse: List(resources.Claimresponse),
    clinicalimpression: List(resources.Clinicalimpression),
    codesystem: List(resources.Codesystem),
    communication: List(resources.Communication),
    communicationrequest: List(resources.Communicationrequest),
    compartmentdefinition: List(resources.Compartmentdefinition),
    composition: List(resources.Composition),
    conceptmap: List(resources.Conceptmap),
    condition: List(resources.Condition),
    consent: List(resources.Consent),
    contract: List(resources.Contract),
    coverage: List(resources.Coverage),
    coverageeligibilityrequest: List(
      resources.Coverageeligibilityrequest,
    ),
    coverageeligibilityresponse: List(
      resources.Coverageeligibilityresponse,
    ),
    detectedissue: List(resources.Detectedissue),
    device: List(resources.Device),
    devicedefinition: List(resources.Devicedefinition),
    devicemetric: List(resources.Devicemetric),
    devicerequest: List(resources.Devicerequest),
    deviceusestatement: List(resources.Deviceusestatement),
    diagnosticreport: List(resources.Diagnosticreport),
    documentmanifest: List(resources.Documentmanifest),
    documentreference: List(resources.Documentreference),
    effectevidencesynthesis: List(
      resources.Effectevidencesynthesis,
    ),
    encounter: List(resources.Encounter),
    endpoint: List(resources.Endpoint),
    enrollmentrequest: List(resources.Enrollmentrequest),
    enrollmentresponse: List(resources.Enrollmentresponse),
    episodeofcare: List(resources.Episodeofcare),
    eventdefinition: List(resources.Eventdefinition),
    evidence: List(resources.Evidence),
    evidencevariable: List(resources.Evidencevariable),
    examplescenario: List(resources.Examplescenario),
    explanationofbenefit: List(resources.Explanationofbenefit),
    familymemberhistory: List(resources.Familymemberhistory),
    flag: List(resources.Flag),
    goal: List(resources.Goal),
    graphdefinition: List(resources.Graphdefinition),
    group: List(resources.Group),
    guidanceresponse: List(resources.Guidanceresponse),
    healthcareservice: List(resources.Healthcareservice),
    imagingstudy: List(resources.Imagingstudy),
    immunization: List(resources.Immunization),
    immunizationevaluation: List(resources.Immunizationevaluation),
    immunizationrecommendation: List(
      resources.Immunizationrecommendation,
    ),
    implementationguide: List(resources.Implementationguide),
    insuranceplan: List(resources.Insuranceplan),
    invoice: List(resources.Invoice),
    library: List(resources.Library),
    linkage: List(resources.Linkage),
    listfhir: List(resources.Listfhir),
    location: List(resources.Location),
    measure: List(resources.Measure),
    measurereport: List(resources.Measurereport),
    media: List(resources.Media),
    medication: List(resources.Medication),
    medicationadministration: List(
      resources.Medicationadministration,
    ),
    medicationdispense: List(resources.Medicationdispense),
    medicationknowledge: List(resources.Medicationknowledge),
    medicationrequest: List(resources.Medicationrequest),
    medicationstatement: List(resources.Medicationstatement),
    medicinalproduct: List(resources.Medicinalproduct),
    medicinalproductauthorization: List(
      resources.Medicinalproductauthorization,
    ),
    medicinalproductcontraindication: List(
      resources.Medicinalproductcontraindication,
    ),
    medicinalproductindication: List(
      resources.Medicinalproductindication,
    ),
    medicinalproductingredient: List(
      resources.Medicinalproductingredient,
    ),
    medicinalproductinteraction: List(
      resources.Medicinalproductinteraction,
    ),
    medicinalproductmanufactured: List(
      resources.Medicinalproductmanufactured,
    ),
    medicinalproductpackaged: List(
      resources.Medicinalproductpackaged,
    ),
    medicinalproductpharmaceutical: List(
      resources.Medicinalproductpharmaceutical,
    ),
    medicinalproductundesirableeffect: List(
      resources.Medicinalproductundesirableeffect,
    ),
    messagedefinition: List(resources.Messagedefinition),
    messageheader: List(resources.Messageheader),
    molecularsequence: List(resources.Molecularsequence),
    namingsystem: List(resources.Namingsystem),
    nutritionorder: List(resources.Nutritionorder),
    observation: List(resources.Observation),
    observationdefinition: List(resources.Observationdefinition),
    operationdefinition: List(resources.Operationdefinition),
    operationoutcome: List(resources.Operationoutcome),
    organization: List(resources.Organization),
    organizationaffiliation: List(
      resources.Organizationaffiliation,
    ),
    patient: List(resources.Patient),
    paymentnotice: List(resources.Paymentnotice),
    paymentreconciliation: List(resources.Paymentreconciliation),
    person: List(resources.Person),
    plandefinition: List(resources.Plandefinition),
    practitioner: List(resources.Practitioner),
    practitionerrole: List(resources.Practitionerrole),
    procedure: List(resources.Procedure),
    provenance: List(resources.Provenance),
    questionnaire: List(resources.Questionnaire),
    questionnaireresponse: List(resources.Questionnaireresponse),
    relatedperson: List(resources.Relatedperson),
    requestgroup: List(resources.Requestgroup),
    researchdefinition: List(resources.Researchdefinition),
    researchelementdefinition: List(
      resources.Researchelementdefinition,
    ),
    researchstudy: List(resources.Researchstudy),
    researchsubject: List(resources.Researchsubject),
    riskassessment: List(resources.Riskassessment),
    riskevidencesynthesis: List(resources.Riskevidencesynthesis),
    schedule: List(resources.Schedule),
    searchparameter: List(resources.Searchparameter),
    servicerequest: List(resources.Servicerequest),
    slot: List(resources.Slot),
    specimen: List(resources.Specimen),
    specimendefinition: List(resources.Specimendefinition),
    structuredefinition: List(resources.Structuredefinition),
    structuremap: List(resources.Structuremap),
    subscription: List(resources.Subscription),
    substance: List(resources.Substance),
    substancenucleicacid: List(resources.Substancenucleicacid),
    substancepolymer: List(resources.Substancepolymer),
    substanceprotein: List(resources.Substanceprotein),
    substancereferenceinformation: List(
      resources.Substancereferenceinformation,
    ),
    substancesourcematerial: List(
      resources.Substancesourcematerial,
    ),
    substancespecification: List(resources.Substancespecification),
    supplydelivery: List(resources.Supplydelivery),
    supplyrequest: List(resources.Supplyrequest),
    task: List(resources.Task),
    terminologycapabilities: List(
      resources.Terminologycapabilities,
    ),
    testreport: List(resources.Testreport),
    testscript: List(resources.Testscript),
    valueset: List(resources.Valueset),
    verificationresult: List(resources.Verificationresult),
    visionprescription: List(resources.Visionprescription),
  )
}

Constructors

Logging

</> 
pub type Logging {
  LoggingOn
  LoggingOff
}

Constructors 

  • LoggingOn
  • LoggingOff

OperationoutcomeOrHTTP

</> 
pub type OperationoutcomeOrHTTP {
  SuccessOperationoutcome(resources.Operationoutcome)
  SuccessHttpResponse(response.Response(String))
}

Constructors

PostBundleType

</> 
pub type PostBundleType {
  Transaction
  Batch
}

Constructors 

  • Transaction

    server executes all operations in transaction as one atomic operation

  • Batch

    server executes each operation in batch independently meaning an operation can fail without stopping other operations

Values

any_create_req

</> 
pub fn any_create_req(
  resource_json: json.Json,
  res_type: resources.ResourceType,
  client: FhirClient,
) -> request.Request(option.Option(json.Json))

any_delete_req

</> 
pub fn any_delete_req(
  id: String,
  res_type: resources.ResourceType,
  client: FhirClient,
) -> request.Request(option.Option(json.Json))

any_operation_req

</> 
pub fn any_operation_req(
  res_type: resources.ResourceType,
  res_id: option.Option(String),
  operation_name: String,
  params: option.Option(resources.Parameters),
  client: FhirClient,
) -> request.Request(option.Option(json.Json))

any_read_req

</> 
pub fn any_read_req(
  id: String,
  res_type: resources.ResourceType,
  client: FhirClient,
) -> request.Request(option.Option(json.Json))

any_resp

</> 
pub fn any_resp(
  resp: response.Response(String),
  resource_dec: decode.Decoder(a),
  resource_type: resources.ResourceType,
) -> Result(a, ErrResp)

decodes an Ok(resource) of given decoder type or Error(ErrOperationoutcome(operationoutcome))

if resp.body is not a JSON, returns Error(ErrNotJson(resp))

any_search_req

</> 
pub fn any_search_req(
  search_string: String,
  res_type: resources.ResourceType,
  client: FhirClient,
) -> request.Request(option.Option(json.Json))

any_update_req

</> 
pub fn any_update_req(
  id: option.Option(String),
  resource_json: json.Json,
  res_type: resources.ResourceType,
  client: FhirClient,
) -> Result(request.Request(option.Option(json.Json)), ErrReq)

batch_req

</> 
pub fn batch_req(
  reqs: List(request.Request(option.Option(json.Json))),
  bundle_type: PostBundleType,
  client: FhirClient,
) -> request.Request(option.Option(json.Json))

bundle_next_page_req

</> 
pub fn bundle_next_page_req(
  bundle: resources.Bundle,
  client: FhirClient,
) -> Result(request.Request(option.Option(json.Json)), Nil)

bundle_next_page_req_forgiving

</> 
pub fn bundle_next_page_req_forgiving(
  bundle: resources.BundleForgiving,
  client: FhirClient,
) -> Result(request.Request(option.Option(json.Json)), Nil)

bundle_to_groupedresources

</> 
pub fn bundle_to_groupedresources(
  from bundle: resources.Bundle,
) -> GroupedResources

fhirclient_new

</> 
pub fn fhirclient_new(
  server_base_url in_url: String,
) -> Result(FhirClient, ErrBaseUrl)

creates a new client from server base url

let assert Ok(client) = sansio.fhirclient_new("r4.smarthealthit.org/")

let assert Ok(client) = sansio.fhirclient_new("https://r4.smarthealthit.org/")

let assert Ok(client) = sansio.fhirclient_new("https://hapi.fhir.org/baser4")

let assert Ok(client) = sansio.fhirclient_new("127.0.0.1:8000")

groupedresources_new

</> 
pub fn groupedresources_new() -> GroupedResources

http_or_operationoutcome_resp

</> 
pub fn http_or_operationoutcome_resp(
  resp: response.Response(String),
) -> Result(OperationoutcomeOrHTTP, ErrResp)

returns Ok if http status code 200-299, otherwise Error, and can return an OperationOutcome or HTTP response, depending on if server sense OperationOutcome or empty body

req_to_string

</> 
pub fn req_to_string(
  req: request.Request(option.Option(json.Json)),
) -> String

resp_to_string

</> 
pub fn resp_to_string(resp: response.Response(String)) -> String

set_access_token

</> 
pub fn set_access_token(
  client: FhirClient,
  token: String,
) -> FhirClient

use SMART app access token when making requests with client

✨ Search Document