@healthcloudai/hc-safe-cdx 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,10 +1,5 @@
 // src/client.ts
-import {
-  APIError,
-  ConfigError,
-  HCServiceError,
-  ValidationError
-} from "@healthcloudai/hc-http";
+import { HCBaseConnector, APIError, ConfigError, HCServiceError, ValidationError } from "@healthcloudai/hc-http";
 var ENV_HOST = {
   dev: "dev-api-hcs.healthcloud-services.com",
   uat: "uat-api-hcs.healthcloud-services.com",
@@ -29,24 +24,12 @@ function buildUrl(baseUrl, route, query) {
   }
   return url.toString();
 }
-var HCSafeCDXClient = class {
+var HCSafeCDXClient = class extends HCBaseConnector {
   constructor(httpClient, loginClient) {
-    this.http = httpClient;
-    this.loginClient = loginClient;
+    super(httpClient);
+    this.auth = loginClient;
     this.baseUrl = buildSafeCdxBaseUrl(loginClient.getEnvironment());
   }
-  setApiKey(headerName, value) {
-    const trimmedHeaderName = headerName == null ? void 0 : headerName.trim();
-    const trimmedValue = value == null ? void 0 : value.trim();
-    if (!trimmedHeaderName) {
-      throw new ConfigError("API key header name is required.");
-    }
-    if (!trimmedValue) {
-      throw new ConfigError("API key value is required.");
-    }
-    this.apiKeyHeaderName = trimmedHeaderName;
-    this.apiKeyValue = trimmedValue;
-  }
   // -------------------------------------------------------------------------
   // Test Profiles
   // -------------------------------------------------------------------------
@@ -55,7 +38,7 @@ var HCSafeCDXClient = class {
    * Resolves the SafeCDX test profile associated with a GTIN barcode.
    */
   async getTestProfileByGTIN(gtin) {
-    const resolvedGtin = this.requireValue(gtin, "gtin");
+    const resolvedGtin = this.requireValue(gtin, "GTIN");
     return this.execute(
       "getTestProfileByGTIN",
       () => this.http.get(
@@ -65,23 +48,21 @@ var HCSafeCDXClient = class {
     );
   }
   /**
-       * POST test/profiles/by-account
-  
-       *
-       * TenantId is resolved by the backend from the authenticated patient context.
-       */
-  async getTestProfilesByAccount(includeRegisterTestDetails = true) {
+   * POST test/profiles/by-account
+   *
+   * Returns test profiles configured for the authenticated patient's account.
+   * TenantId is resolved by the backend from the authenticated patient context.
+   */
+  async listTestProfilesByAccount(includeRegisterTestDetails = true) {
     const request = {
-      Data: {
-        IncludeRegisterTestDetails: includeRegisterTestDetails
-      }
+      Data: { IncludeRegisterTestDetails: includeRegisterTestDetails }
     };
-    return this.execute(
-      "getTestProfilesByAccount",
+    return this.executeSafe(
+      "listTestProfilesByAccount",
       () => this.http.post(
         this.url("test/profiles/by-account"),
         request,
-        this.getJsonHeaders()
+        this.getAuthHeaders()
       )
     );
   }
@@ -93,16 +74,14 @@ var HCSafeCDXClient = class {
    * Requests a pre-signed URL used to upload a test image.
    */
   async createUploadUrl(userTestResultId, gtin, imageType = "jpg") {
-    const resolvedUserTestResultId = this.requireValue(userTestResultId, "userTestResultId");
-    const resolvedGtin = this.requireValue(gtin, "gtin");
-    const resolvedImageType = this.requireValue(imageType, "imageType");
+    const resolvedUserTestResultId = this.requireValue(userTestResultId, "User test result ID");
+    const resolvedGtin = this.requireValue(gtin, "GTIN");
+    const resolvedImageType = this.requireValue(imageType, "Image type");
     const request = {
       Data: {
         Gtin: resolvedGtin,
         UserTestResultId: resolvedUserTestResultId,
-        Metadata: {
-          ImageType: resolvedImageType
-        }
+        Metadata: { ImageType: resolvedImageType }
       }
     };
     return this.execute(
@@ -110,7 +89,7 @@ var HCSafeCDXClient = class {
       () => this.http.post(
         this.url("upload/url"),
         request,
-        this.getJsonHeaders()
+        this.getAuthHeaders()
       )
     );
   }
@@ -118,17 +97,19 @@ var HCSafeCDXClient = class {
    * PUT preSignedURL
    * Uploads the image directly to the pre-signed storage URL.
    *
-   * This request does not call a SafeCDX API route and does not send
-   * authenticated Health Cloud headers.
+   * This request does NOT call a SafeCDX API route and does NOT send
+   * Health Cloud auth headers — it targets the storage provider directly.
+   * The pre-signed URL embeds credentials; no Authorization header is needed.
    */
   async uploadImage(preSignedURL, image, contentType = "image/jpeg") {
-    const resolvedPreSignedURL = this.requireValue(preSignedURL, "preSignedURL");
-    const resolvedContentType = this.requireValue(contentType, "contentType");
+    const resolvedPreSignedURL = this.requireValue(preSignedURL, "Pre-signed URL");
+    const resolvedContentType = this.requireValue(contentType, "Content type");
+    if (image == null) {
+      throw new ValidationError({ message: "Image is required.", code: "INVALID_INPUT" });
+    }
     const response = await fetch(resolvedPreSignedURL, {
       method: "PUT",
-      headers: {
-        "Content-Type": resolvedContentType
-      },
+      headers: { "Content-Type": resolvedContentType },
       body: image
     });
     if (!response.ok) {
@@ -143,10 +124,7 @@ var HCSafeCDXClient = class {
         code: response.status >= 500 ? "SERVER_ERROR" : "UNKNOWN_ERROR",
         statusCode: response.status,
         backendMessage: body,
-        details: {
-          status: response.status,
-          body
-        }
+        details: { status: response.status, body }
       });
     }
   }
@@ -155,11 +133,11 @@ var HCSafeCDXClient = class {
   // -------------------------------------------------------------------------
   /**
    * POST cvml/status
-   * Returns the direct SafeCDX response without an outer APIResponse wrapper.
+   * Updates the CVML processing status for an image capture.
    */
   async updateCvmlStatus(imageOfCaptureId, cvmlStatus) {
-    const resolvedImageOfCaptureId = this.requireValue(imageOfCaptureId, "imageOfCaptureId");
-    const resolvedCvmlStatus = this.requireValue(cvmlStatus, "cvmlStatus");
+    const resolvedImageOfCaptureId = this.requireValue(imageOfCaptureId, "Image capture ID");
+    const resolvedCvmlStatus = this.requireValue(cvmlStatus, "CVML status");
     const request = {
       Data: {
         ImageOfCaptureId: resolvedImageOfCaptureId,
@@ -168,15 +146,15 @@ var HCSafeCDXClient = class {
     };
     return this.executeSafe(
       "updateCvmlStatus",
-      () => this.http.post(this.url("cvml/status"), request, this.getJsonHeaders())
+      () => this.http.post(this.url("cvml/status"), request, this.getAuthHeaders())
     );
   }
   /**
    * GET cvml/results
-   * Returns the direct SafeCDX response without an outer APIResponse wrapper.
+   * Returns the CVML analysis results for an image capture.
    */
   async getCvmlResults(imageOfCaptureId) {
-    const resolvedImageOfCaptureId = this.requireValue(imageOfCaptureId, "imageOfCaptureId");
+    const resolvedImageOfCaptureId = this.requireValue(imageOfCaptureId, "Image capture ID");
     return this.executeSafe(
       "getCvmlResults",
       () => this.http.get(
@@ -188,85 +166,73 @@ var HCSafeCDXClient = class {
   // -------------------------------------------------------------------------
   // Test Results
   // -------------------------------------------------------------------------
-  /** POST test/result/pending */
-  async getPendingResults(excludeStatus = "Invalid,Canceled") {
+  /** POST test/result/pending — returns pending test results excluding the given statuses. */
+  async listPendingResults(excludeStatus = "Invalid,Canceled") {
     const request = {
-      Data: {
-        ExcludeStatus: excludeStatus
-      }
+      Data: { ExcludeStatus: excludeStatus }
     };
-    return this.execute(
-      "getPendingResults",
-      () => this.http.post(this.url("test/result/pending"), request, this.getJsonHeaders())
+    return this.executeSafe(
+      "listPendingResults",
+      () => this.http.post(this.url("test/result/pending"), request, this.getAuthHeaders())
     );
   }
-  /** POST test/result/last */
+  /** POST test/result/last — returns the most recent test result. */
   async getLastResults(excludeStatus = "Invalid") {
     const request = {
-      Data: {
-        ExcludeStatus: excludeStatus
-      }
+      Data: { ExcludeStatus: excludeStatus }
     };
-    return this.execute(
+    return this.executeSafe(
       "getLastResults",
-      () => this.http.post(this.url("test/result/last"), request, this.getJsonHeaders())
+      () => this.http.post(this.url("test/result/last"), request, this.getAuthHeaders())
     );
   }
-  /** POST test/result/history */
-  async getTestHistory(excludeStatus = "Invalid") {
+  /** POST test/result/history — returns all test results excluding the given statuses. */
+  async listTestHistory(excludeStatus = "Invalid") {
     const request = {
-      Data: {
-        ExcludeStatus: excludeStatus
-      }
+      Data: { ExcludeStatus: excludeStatus }
     };
-    return this.execute(
-      "getTestHistory",
-      () => this.http.post(this.url("test/result/history"), request, this.getJsonHeaders())
+    return this.executeSafe(
+      "listTestHistory",
+      () => this.http.post(this.url("test/result/history"), request, this.getAuthHeaders())
     );
   }
   /**
    * POST test/result/details
-   * Returns the direct SafeCDX response without an outer APIResponse wrapper.
+   * Returns full details for a single test result.
    */
   async getResultDetails(userTestResultId) {
-    const resolvedUserTestResultId = this.requireValue(userTestResultId, "userTestResultId");
+    const resolvedUserTestResultId = this.requireValue(userTestResultId, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: resolvedUserTestResultId
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId }
     };
     return this.executeSafe(
       "getResultDetails",
-      () => this.http.post(this.url("test/result/details"), request, this.getJsonHeaders())
+      () => this.http.post(this.url("test/result/details"), request, this.getAuthHeaders())
     );
   }
-  /** POST test/result/pdf */
+  /** POST test/result/pdf — returns the PDF report for a test result. */
   async getResultPdf(userTestResultId) {
-    const resolvedUserTestResultId = this.requireValue(userTestResultId, "userTestResultId");
+    const resolvedUserTestResultId = this.requireValue(userTestResultId, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: resolvedUserTestResultId
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId }
     };
-    return this.execute(
+    return this.executeSafe(
       "getResultPdf",
-      () => this.http.post(this.url("test/result/pdf"), request, this.getJsonHeaders())
+      () => this.http.post(this.url("test/result/pdf"), request, this.getAuthHeaders())
     );
   }
   /**
    * POST test/result/image/capture
-   * Returns the direct SafeCDX response without an outer APIResponse wrapper.
+   * Returns a URL to capture an image for the given test result.
    */
   async getImageCaptureUrl(userTestResultId) {
-    const resolvedUserTestResultId = this.requireValue(userTestResultId, "userTestResultId");
+    const resolvedUserTestResultId = this.requireValue(userTestResultId, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: resolvedUserTestResultId
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId }
     };
     return this.executeSafe(
       "getImageCaptureUrl",
-      () => this.http.post(this.url("test/result/image/capture"), request, this.getJsonHeaders())
+      () => this.http.post(this.url("test/result/image/capture"), request, this.getAuthHeaders())
     );
   }
   // -------------------------------------------------------------------------
@@ -274,152 +240,81 @@ var HCSafeCDXClient = class {
   // -------------------------------------------------------------------------
   /** POST test/resume */
   async resumeFlow(userTestResultId, resumed = true) {
-    const resolvedUserTestResultId = this.requireValue(userTestResultId, "userTestResultId");
+    const resolvedUserTestResultId = this.requireValue(userTestResultId, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: resolvedUserTestResultId,
-        Resumed: resumed
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId, Resumed: resumed }
     };
-    return this.execute(
+    return this.executeSafe(
       "resumeFlow",
-      () => this.http.post(this.url("test/resume"), request, this.getJsonHeaders())
+      () => this.http.post(this.url("test/resume"), request, this.getAuthHeaders())
     );
   }
   /** POST test/answers */
   async submitAnswers(submission) {
+    const resolvedId = this.requireValue(submission == null ? void 0 : submission.UserTestResultId, "User test result ID");
+    if (!(submission == null ? void 0 : submission.Result) || submission.Result.length === 0) {
+      throw new ValidationError({
+        message: "At least one answer result is required.",
+        code: "INVALID_INPUT",
+        param: "Result"
+      });
+    }
     const request = {
-      Data: submission
+      Data: { ...submission, UserTestResultId: resolvedId }
     };
-    return this.execute(
+    return this.executeSafe(
       "submitAnswers",
-      () => this.http.post(this.url("test/answers"), request, this.getJsonHeaders())
+      () => this.http.post(this.url("test/answers"), request, this.getAuthHeaders())
     );
   }
   /** POST test/finalize */
   async finalizeTest(userTestResultId) {
-    const resolvedUserTestResultId = this.requireValue(userTestResultId, "userTestResultId");
+    const resolvedUserTestResultId = this.requireValue(userTestResultId, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: resolvedUserTestResultId
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId }
     };
     return this.execute(
       "finalizeTest",
-      () => this.http.post(this.url("test/finalize"), request, this.getJsonHeaders())
+      () => this.http.post(this.url("test/finalize"), request, this.getAuthHeaders())
     );
   }
   // -------------------------------------------------------------------------
   // Private Helpers
   // -------------------------------------------------------------------------
-  async execute(operation, request) {
-    const response = await this.executeRaw(operation, request);
-    if (!this.isApiResponse(response)) {
-      throw new APIError({
-        message: `${operation}: invalid API response structure`,
-        code: "INVALID_RESPONSE",
-        details: response
-      });
-    }
-    if (!response.IsOK) {
-      throw new HCServiceError(operation, response.ErrorMessage, response);
-    }
-    return response;
-  }
   async executeSafe(operation, request) {
-    var _a, _b;
-    const response = await this.executeRaw(operation, request);
-    if (!this.isSafeApiResponse(response)) {
-      throw new APIError({
-        message: `${operation}: invalid SafeCDX response structure`,
-        code: "INVALID_RESPONSE",
-        details: response
-      });
-    }
-    if (!response.success) {
-      throw new APIError({
-        message: (_a = response.message) != null ? _a : `${operation}: backend returned success: false`,
-        code: "BACKEND_FAILURE",
-        statusCode: 200,
-        backendMessage: (_b = response.message) != null ? _b : void 0,
-        details: response
-      });
-    }
-    return response;
-  }
-  async executeRaw(operation, request) {
+    var _a;
     let response;
     try {
       response = await request();
     } catch (err) {
-      if (err instanceof APIError) {
-        throw err;
-      }
+      if (err instanceof APIError) throw err;
       if (err instanceof Error) {
-        throw new APIError({
-          message: `${operation}: ${err.message}`,
-          code: "UNKNOWN_ERROR",
-          details: err
-        });
+        throw new APIError({ message: `${operation}: ${err.message}`, code: "UNKNOWN_ERROR", details: err });
       }
-      throw new APIError({
-        message: `${operation}: unexpected runtime failure`,
-        code: "UNKNOWN_ERROR",
-        details: err
-      });
+      throw new APIError({ message: `${operation}: unexpected runtime failure`, code: "UNKNOWN_ERROR", details: err });
     }
     if (response == null) {
-      throw new APIError({
-        message: `${operation}: empty response received`,
-        code: "EMPTY_RESPONSE",
-        details: response
-      });
+      throw new APIError({ message: `${operation}: empty response received`, code: "EMPTY_RESPONSE", details: response });
     }
-    return response;
-  }
-  isApiResponse(value) {
-    if (!value || typeof value !== "object") {
-      return false;
+    if (!this.isSafeApiResponse(response)) {
+      throw new APIError({ message: `${operation}: invalid SafeCDX response structure`, code: "INVALID_RESPONSE", details: response });
     }
-    const response = value;
-    return "IsOK" in response && typeof response.IsOK === "boolean" && "Data" in response && "ErrorMessage" in response;
-  }
-  isSafeApiResponse(value) {
-    if (!value || typeof value !== "object") {
-      return false;
+    if (!response.success) {
+      throw new HCServiceError(
+        operation,
+        (_a = response.message) != null ? _a : "Backend returned success: false",
+        response
+      );
     }
-    const response = value;
-    return "success" in response && typeof response.success === "boolean" && "data" in response && "message" in response && "code" in response && typeof response.code === "number";
+    return response;
   }
-  requireValue(value, parameterName) {
-    const trimmedValue = value == null ? void 0 : value.trim();
-    if (!trimmedValue) {
-      throw new ValidationError({
-        message: `${parameterName} is required.`,
-        code: "INVALID_INPUT"
-      });
-    }
-    return trimmedValue;
+  isSafeApiResponse(value) {
+    if (!value || typeof value !== "object") return false;
+    const r = value;
+    return "success" in r && typeof r.success === "boolean" && "data" in r && "message" in r && "code" in r && typeof r.code === "number";
   }
   getAuthHeaders() {
-    return {
-      ...this.loginClient.getAuthHeader(),
-      ...this.getApiKeyHeader()
-    };
-  }
-  getJsonHeaders() {
-    return {
-      ...this.getAuthHeaders(),
-      "Content-Type": "application/json"
-    };
-  }
-  getApiKeyHeader() {
-    if (!this.apiKeyHeaderName || !this.apiKeyValue) {
-      return {};
-    }
-    return {
-      [this.apiKeyHeaderName]: this.apiKeyValue
-    };
+    return { ...this.getHeaders(), ...this.auth.getAuthHeader() };
   }
   url(route, query) {
     return buildUrl(this.baseUrl, route, query);
@@ -432,8 +327,7 @@ import {
   ConfigError as ConfigError2,
   HCServiceError as HCServiceError2,
   NetworkError,
-  ValidationError as ValidationError2,
-  errorFromHttpStatus
+  ValidationError as ValidationError2
 } from "@healthcloudai/hc-http";
 export {
   APIError2 as APIError,
@@ -441,6 +335,5 @@ export {
   HCSafeCDXClient,
   HCServiceError2 as HCServiceError,
   NetworkError,
-  ValidationError2 as ValidationError,
-  errorFromHttpStatus
+  ValidationError2 as ValidationError
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@healthcloudai/hc-safe-cdx",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Healthcheck Safe CDX connector.",
   "author": "Healthcheck Systems Inc",
   "license": "MIT",
@@ -33,8 +33,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@healthcloudai/hc-http": "^0.1.0",
-    "@healthcloudai/hc-login-connector": "^0.2.0"
+    "@healthcloudai/hc-http": "^0.2.0",
+    "@healthcloudai/hc-login-connector": "^0.3.0"
   },
   "peerDependencies": {
     "react-native": ">=0.70.0"