@haste-health/client 0.15.3

package/src/interface.ts

@@ -0,0 +1,203 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { code } from "@haste-health/fhir-types/lib/generated/r4/types";
+import {
+  AllResourceTypes,
+  FHIR_VERSION,
+  Resource,
+  ResourceType,
+} from "@haste-health/fhir-types/versions";
+import type { IOperation, OPMetadata } from "@haste-health/operation-execution";
+
+import { MiddlewareAsync } from "./middleware/index.js";
+import type {
+  AllInteractions,
+  FHIRRequest,
+  FHIRResponse,
+} from "./types/index.js";
+import type { ParsedParameter } from "./url.js";
+
+export type FHIRClient<CTX> = FHIRClientAsync<CTX>;
+
+export type InvokeParameter<
+  FHIRVersion extends FHIR_VERSION,
+  Op,
+  direction extends "Output" | "Input"
+> = Op extends IOperation<any, any>
+  ? OPMetadata<Op>[direction]
+  : Resource<FHIRVersion, "Parameters">;
+
+export interface FHIRClientAsync<CTX> {
+  request<Version extends FHIR_VERSION, I extends AllInteractions>(
+    ctx: CTX,
+    request: FHIRRequest<Version, I>
+  ): Promise<FHIRResponse<Version, I | "error">>;
+  middleware: MiddlewareAsync<CTX>;
+  capabilities<FHIRVersion extends FHIR_VERSION>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion
+  ): Promise<Resource<FHIRVersion, "CapabilityStatement">>;
+  search_system<FHIRVersion extends FHIR_VERSION>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    parameters: ParsedParameter<string | number>[] | string
+  ): Promise<{
+    total?: number;
+    resources: Resource<FHIRVersion, ResourceType<FHIRVersion>>[];
+  }>;
+  search_type<
+    FHIRVersion extends FHIR_VERSION,
+    T extends ResourceType<FHIRVersion>
+  >(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    type: T,
+    parameters: ParsedParameter<string | number>[] | string
+  ): Promise<{
+    total?: number;
+    resources: Resource<FHIRVersion, T>[];
+  }>;
+  create<
+    FHIRVersion extends FHIR_VERSION,
+    Value extends Resource<FHIRVersion, AllResourceTypes>
+  >(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resource: Value
+  ): Promise<Value>;
+
+  update<FHIRVersion extends FHIR_VERSION, T extends ResourceType<FHIRVersion>>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    id: NonNullable<Resource<FHIRVersion, ResourceType<FHIRVersion>>["id"]>,
+    resource: Resource<FHIRVersion, T>
+  ): Promise<Resource<FHIRVersion, T>>;
+  conditionalUpdate<
+    FHIRVersion extends FHIR_VERSION,
+    T extends ResourceType<FHIRVersion>
+  >(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    parameters: ParsedParameter<string | number>[] | string,
+    resource: Resource<FHIRVersion, T>
+  ): Promise<Resource<FHIRVersion, T>>;
+  patch<FHIRVersion extends FHIR_VERSION, T extends ResourceType<FHIRVersion>>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    id: NonNullable<Resource<FHIRVersion, ResourceType<FHIRVersion>>["id"]>,
+    patches: any
+  ): Promise<Resource<FHIRVersion, T>>;
+  read<FHIRVersion extends FHIR_VERSION, T extends ResourceType<FHIRVersion>>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    id: NonNullable<Resource<FHIRVersion, ResourceType<FHIRVersion>>["id"]>
+  ): Promise<Resource<FHIRVersion, T> | undefined>;
+  vread<FHIRVersion extends FHIR_VERSION, T extends ResourceType<FHIRVersion>>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    id: NonNullable<Resource<FHIRVersion, ResourceType<FHIRVersion>>["id"]>,
+    versionId: NonNullable<
+      Resource<FHIRVersion, ResourceType<FHIRVersion>>["id"]
+    >
+  ): Promise<Resource<FHIRVersion, T> | undefined>;
+  delete_instance<
+    FHIRVersion extends FHIR_VERSION,
+    T extends ResourceType<FHIRVersion>
+  >(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    id: NonNullable<Resource<FHIRVersion, ResourceType<FHIRVersion>>["id"]>
+  ): Promise<void>;
+  delete_type<
+    FHIRVersion extends FHIR_VERSION,
+    T extends ResourceType<FHIRVersion>
+  >(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    parameters?: ParsedParameter<string | number>[] | string
+  ): Promise<void>;
+  delete_system<FHIRVersion extends FHIR_VERSION>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    parameters?: ParsedParameter<string | number>[] | string
+  ): Promise<void>;
+
+  history_system<FHIRVersion extends FHIR_VERSION>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    parameters?: ParsedParameter<string | number>[] | string
+  ): Promise<NonNullable<Resource<FHIRVersion, "Bundle">["entry"]>>;
+  history_type<
+    FHIRVersion extends FHIR_VERSION,
+    T extends ResourceType<FHIRVersion>
+  >(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    parameters?: ParsedParameter<string | number>[] | string
+  ): Promise<NonNullable<Resource<FHIRVersion, "Bundle">["entry"]>>;
+  history_instance<
+    FHIRVersion extends FHIR_VERSION,
+    T extends ResourceType<FHIRVersion>
+  >(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    id: NonNullable<Resource<FHIRVersion, ResourceType<FHIRVersion>>["id"]>,
+    parameters?: ParsedParameter<string | number>[] | string
+  ): Promise<NonNullable<Resource<FHIRVersion, "Bundle">["entry"]>>;
+  invoke_system<
+    FHIRVersion extends FHIR_VERSION,
+    Op extends IOperation<any, any> | code,
+    Input extends InvokeParameter<FHIRVersion, Op, "Input">,
+    Output extends InvokeParameter<FHIRVersion, Op, "Output">
+  >(
+    op: Op,
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    input: Input
+  ): Promise<Output>;
+  invoke_type<
+    FHIRVersion extends FHIR_VERSION,
+    Op extends IOperation<any, any> | code,
+    Input extends InvokeParameter<FHIRVersion, Op, "Input">,
+    Output extends InvokeParameter<FHIRVersion, Op, "Output">,
+    T extends ResourceType<FHIRVersion>
+  >(
+    op: Op,
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    input: Input
+  ): Promise<Output>;
+  invoke_instance<
+    FHIRVersion extends FHIR_VERSION,
+    Op extends IOperation<any, any> | code,
+    Input extends InvokeParameter<FHIRVersion, Op, "Input">,
+    Output extends InvokeParameter<FHIRVersion, Op, "Output">,
+    T extends ResourceType<FHIRVersion>
+  >(
+    op: Op,
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    resourceType: T,
+    id: NonNullable<Resource<FHIRVersion, ResourceType<FHIRVersion>>["id"]>,
+    input: Input
+  ): Promise<Output>;
+  transaction<FHIRVersion extends FHIR_VERSION>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    bundle: Resource<FHIRVersion, "Bundle">
+  ): Promise<Resource<FHIRVersion, "Bundle">>;
+  batch<FHIRVersion extends FHIR_VERSION>(
+    ctx: CTX,
+    fhirVersion: FHIRVersion,
+    bundle: Resource<FHIRVersion, "Bundle">
+  ): Promise<Resource<FHIRVersion, "Bundle">>;
+}

package/src/middleware/index.test.ts

@@ -0,0 +1,120 @@
+import { expect, test } from "@jest/globals";
+
+import { Bundle, code } from "@haste-health/fhir-types/lib/generated/r4/types";
+import { FHIR_VERSION, R4 } from "@haste-health/fhir-types/lib/versions";
+
+import { AllInteractions, FHIRResponse } from "../types/index.js";
+import type { ParsedParameter } from "../url";
+import { createMiddlewareAsync } from "./index.js";
+
+test("Test middleware Async", async () => {
+  const middleware = createMiddlewareAsync<{}, {}>({}, [
+    async (state, context, next) => {
+      if (next) {
+        const [nextState, res] = await next(state, context);
+        return [
+          nextState,
+          {
+            ...res,
+            response: {
+              ...res.response,
+              body: {
+                ...((res as any).response?.body as any),
+                entry: (res.response as any).body?.entry?.map((e: any) => ({
+                  ...e,
+                  resource: {
+                    id: "123",
+                    ...e.resource,
+                  },
+                })),
+              } as Bundle,
+            } as FHIRResponse<FHIR_VERSION, AllInteractions>,
+          },
+        ];
+      }
+      return [
+        state,
+        {
+          ...context,
+
+          response: {
+            fhirVersion: R4,
+            parameters: (context.request as any).parameters
+              ? ((context.request as any).parameters as ParsedParameter<
+                  string | number
+                >[])
+              : [],
+            type: "search-response",
+            level: "system",
+            body: {
+              resourceType: "Bundle",
+              type: "searchset" as code,
+              entry: [],
+            } as Bundle,
+          },
+        },
+      ];
+    },
+    async (state, context, next) => {
+      return [
+        state,
+        {
+          ...context,
+          response: {
+            fhirVersion: R4,
+            parameters: (context.request as any).parameters
+              ? ((context.request as any).parameters as ParsedParameter<
+                  string | number
+                >[])
+              : [],
+            type: "search-response",
+            level: "system",
+            body: {
+              resourceType: "Bundle",
+              type: "searchset" as code,
+              entry: [{ resource: { resourceType: "Patient" } }],
+            } as Bundle,
+          },
+        },
+      ];
+    },
+  ]);
+
+  const result = middleware({
+    key: "test",
+    ctx: {},
+    request: {} as any,
+  });
+  expect(result).toBeInstanceOf(Promise);
+  expect(await result).toEqual({
+    key: "test",
+    request: {},
+    ctx: {},
+    response: {
+      fhirVersion: R4,
+      parameters: [],
+      type: "search-response",
+      level: "system",
+      body: {
+        resourceType: "Bundle",
+        type: "searchset",
+        entry: [{ resource: { id: "123", resourceType: "Patient" } }],
+      },
+    },
+  });
+});
+
+test("Test state", async () => {
+  const middleware = createMiddlewareAsync<number, {}, number, number>(5, [
+    async (state, context, next) => {
+      const [nextState, res] = await next(state, context);
+      return [
+        res.request + nextState,
+        { ...res, response: state + context.request },
+      ];
+    },
+  ]);
+
+  expect((await middleware({ ctx: {}, request: 5 })).response).toEqual(10);
+  expect((await middleware({ ctx: {}, request: 5 })).response).toEqual(15);
+});

package/src/middleware/index.ts

@@ -0,0 +1,95 @@
+import { FHIR_VERSION } from "@haste-health/fhir-types/versions";
+
+import { AllInteractions, FHIRRequest, FHIRResponse } from "../types/index.js";
+
+type Context<CTX, Request, Response> = {
+  key?: string;
+  ctx: CTX;
+  request: Request;
+  response?: Response;
+};
+
+export type MiddlewareAsyncChain<
+  State,
+  CTX,
+  Request = FHIRRequest<FHIR_VERSION, AllInteractions>,
+  Response = FHIRResponse<FHIR_VERSION, AllInteractions | "error">
+> = (
+  state: State,
+  ctx: Context<CTX, Request, Response>,
+  next: Next<State, CTX, Request, Response>
+) => Promise<[State, Context<CTX, Request, Response>]>;
+
+type Next<
+  State,
+  CTX,
+  Request = FHIRRequest<FHIR_VERSION, AllInteractions>,
+  Response = FHIRResponse<FHIR_VERSION, AllInteractions | "error">
+> = (
+  state: State,
+  context: Context<CTX, Request, Response>
+) => Promise<[State, Context<CTX, Request, Response>]>;
+
+export type MiddlewareAsync<
+  CTX,
+  Request = FHIRRequest<FHIR_VERSION, AllInteractions>,
+  Response = FHIRResponse<FHIR_VERSION, AllInteractions | "error">
+> = (
+  ctx: Context<CTX, Request, Response>
+) => Promise<Context<CTX, Request, Response>>;
+
+function createNext<
+  State,
+  CTX,
+  Request = FHIRRequest<FHIR_VERSION, AllInteractions>,
+  Response = FHIRResponse<FHIR_VERSION, AllInteractions | "error">
+>(
+  middlewareChain: MiddlewareAsyncChain<State, CTX, Request, Response>[],
+  options: { logging?: boolean } = { logging: false }
+): Next<State, CTX, Request, Response> {
+  const [first, ...rest] = middlewareChain;
+
+  if (first) {
+    return async (state, context) => {
+      if (options.logging) console.time(`${context.key}:${first.name}`);
+      const response = await first(state, context, createNext(rest));
+      if (options.logging) console.timeEnd(`${context.key}:${first.name}`);
+      return response;
+    };
+  } else {
+    // placeholder.
+    return async (state, context) => {
+      return [state, context];
+    };
+  }
+}
+
+export function createMiddlewareAsync<
+  State,
+  CTX,
+  Request = FHIRRequest<FHIR_VERSION, AllInteractions>,
+  Response = FHIRResponse<FHIR_VERSION, AllInteractions | "error">
+>(
+  _state: State,
+  middlewareChain: MiddlewareAsyncChain<State, CTX, Request, Response>[],
+  options: { logging?: boolean } = { logging: false }
+): MiddlewareAsync<CTX, Request, Response> {
+  let state = _state;
+
+  return async (context) => {
+    const [first, ...rest] = middlewareChain;
+    context.key = context.key ?? Math.ceil(Math.random() * 10000).toString();
+
+    if (options.logging) console.time(`${context.key}:${first.name}`);
+
+    const [nextState, response] = await first(
+      state,
+      context,
+      createNext(rest, options)
+    );
+    state = nextState;
+
+    if (options.logging) console.timeEnd(`${context.key}:${first.name}`);
+    return response;
+  };
+}