@healthcloudai/hc-safe-cdx 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,12 +1,5 @@
 // src/client.ts
-var SafeCDXError = class _SafeCDXError extends Error {
-  constructor(message, response) {
-    super(message);
-    this.name = "SafeCDXError";
-    this.response = response;
-    Object.setPrototypeOf(this, _SafeCDXError.prototype);
-  }
-};
+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",
@@ -16,7 +9,7 @@ var ROUTE_PREFIX = "api/console/hcservice/safecdx";
 function buildSafeCdxBaseUrl(environment) {
   const host = ENV_HOST[environment];
   if (!host) {
-    throw new SafeCDXError("Invalid Safe CDX environment.");
+    throw new ConfigError("Invalid Safe CDX environment.");
   }
   return `https://${host}/${ROUTE_PREFIX}`;
 }
@@ -31,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 SafeCDXError("API key header name is required.");
-    }
-    if (!trimmedValue) {
-      throw new SafeCDXError("API key value is required.");
-    }
-    this.apiKeyHeaderName = trimmedHeaderName;
-    this.apiKeyValue = trimmedValue;
-  }
   // -------------------------------------------------------------------------
   // Test Profiles
   // -------------------------------------------------------------------------
@@ -57,27 +38,32 @@ var HCSafeCDXClient = class {
    * Resolves the SafeCDX test profile associated with a GTIN barcode.
    */
   async getTestProfileByGTIN(gtin) {
-    return this.http.get(
-      this.url(`gs1/${encodeURIComponent(gtin)}`),
-      this.getAuthHeaders()
+    const resolvedGtin = this.requireValue(gtin, "GTIN");
+    return this.execute(
+      "getTestProfileByGTIN",
+      () => this.http.get(
+        this.url(`gs1/${encodeURIComponent(resolvedGtin)}`),
+        this.getAuthHeaders()
+      )
     );
   }
   /**
-       * 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.http.post(
-      this.url("test/profiles/by-account"),
-      request,
-      this.getJsonHeaders()
+    return this.executeSafe(
+      "listTestProfilesByAccount",
+      () => this.http.post(
+        this.url("test/profiles/by-account"),
+        request,
+        this.getAuthHeaders()
+      )
     );
   }
   // -------------------------------------------------------------------------
@@ -88,34 +74,42 @@ 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, "User test result ID");
+    const resolvedGtin = this.requireValue(gtin, "GTIN");
+    const resolvedImageType = this.requireValue(imageType, "Image type");
     const request = {
       Data: {
-        Gtin: gtin,
-        UserTestResultId: userTestResultId,
-        Metadata: {
-          ImageType: imageType
-        }
+        Gtin: resolvedGtin,
+        UserTestResultId: resolvedUserTestResultId,
+        Metadata: { ImageType: resolvedImageType }
       }
     };
-    return this.http.post(
-      this.url("upload/url"),
-      request,
-      this.getJsonHeaders()
+    return this.execute(
+      "createUploadUrl",
+      () => this.http.post(
+        this.url("upload/url"),
+        request,
+        this.getAuthHeaders()
+      )
     );
   }
   /**
    * 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 response = await fetch(preSignedURL, {
+    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": contentType
-      },
+      headers: { "Content-Type": resolvedContentType },
       body: image
     });
     if (!response.ok) {
@@ -125,9 +119,12 @@ var HCSafeCDXClient = class {
       } catch {
         body = void 0;
       }
-      throw new SafeCDXError(`Image upload failed with HTTP ${response.status}.`, {
-        status: response.status,
-        body
+      throw new APIError({
+        message: `uploadImage: image upload failed with HTTP ${response.status}.`,
+        code: response.status >= 500 ? "SERVER_ERROR" : "UNKNOWN_ERROR",
+        statusCode: response.status,
+        backendMessage: body,
+        details: { status: response.status, body }
       });
     }
   }
@@ -136,138 +133,188 @@ 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, "Image capture ID");
+    const resolvedCvmlStatus = this.requireValue(cvmlStatus, "CVML status");
     const request = {
       Data: {
-        ImageOfCaptureId: imageOfCaptureId,
-        CvmlStatus: cvmlStatus
+        ImageOfCaptureId: resolvedImageOfCaptureId,
+        CvmlStatus: resolvedCvmlStatus
       }
     };
-    return this.http.post(this.url("cvml/status"), request, this.getJsonHeaders());
+    return this.executeSafe(
+      "updateCvmlStatus",
+      () => 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) {
-    return this.http.get(this.url("cvml/results", { imageOfCaptureId }), this.getAuthHeaders());
+    const resolvedImageOfCaptureId = this.requireValue(imageOfCaptureId, "Image capture ID");
+    return this.executeSafe(
+      "getCvmlResults",
+      () => this.http.get(
+        this.url("cvml/results", { imageOfCaptureId: resolvedImageOfCaptureId }),
+        this.getAuthHeaders()
+      )
+    );
   }
   // -------------------------------------------------------------------------
   // 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.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.http.post(this.url("test/result/last"), request, this.getJsonHeaders());
+    return this.executeSafe(
+      "getLastResults",
+      () => 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.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, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: userTestResultId
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId }
     };
-    return this.http.post(this.url("test/result/details"), request, this.getJsonHeaders());
+    return this.executeSafe(
+      "getResultDetails",
+      () => 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, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: userTestResultId
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId }
     };
-    return this.http.post(this.url("test/result/pdf"), request, this.getJsonHeaders());
+    return this.executeSafe(
+      "getResultPdf",
+      () => 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, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: userTestResultId
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId }
     };
-    return this.http.post(this.url("test/result/image/capture"), request, this.getJsonHeaders());
+    return this.executeSafe(
+      "getImageCaptureUrl",
+      () => this.http.post(this.url("test/result/image/capture"), request, this.getAuthHeaders())
+    );
   }
   // -------------------------------------------------------------------------
   // Resume / Answers / Finalize
   // -------------------------------------------------------------------------
   /** POST test/resume */
   async resumeFlow(userTestResultId, resumed = true) {
+    const resolvedUserTestResultId = this.requireValue(userTestResultId, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: userTestResultId,
-        Resumed: resumed
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId, Resumed: resumed }
     };
-    return this.http.post(this.url("test/resume"), request, this.getJsonHeaders());
+    return this.executeSafe(
+      "resumeFlow",
+      () => 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.http.post(this.url("test/answers"), request, this.getJsonHeaders());
+    return this.executeSafe(
+      "submitAnswers",
+      () => this.http.post(this.url("test/answers"), request, this.getAuthHeaders())
+    );
   }
   /** POST test/finalize */
   async finalizeTest(userTestResultId) {
+    const resolvedUserTestResultId = this.requireValue(userTestResultId, "User test result ID");
     const request = {
-      Data: {
-        UserTestResultId: userTestResultId
-      }
+      Data: { UserTestResultId: resolvedUserTestResultId }
     };
-    return this.http.post(this.url("test/finalize"), request, this.getJsonHeaders());
+    return this.execute(
+      "finalizeTest",
+      () => this.http.post(this.url("test/finalize"), request, this.getAuthHeaders())
+    );
   }
   // -------------------------------------------------------------------------
   // Private Helpers
   // -------------------------------------------------------------------------
-  getAuthHeaders() {
-    return {
-      ...this.loginClient.getAuthHeader(),
-      ...this.getApiKeyHeader()
-    };
+  async executeSafe(operation, request) {
+    var _a;
+    let response;
+    try {
+      response = await request();
+    } catch (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}: unexpected runtime failure`, code: "UNKNOWN_ERROR", details: err });
+    }
+    if (response == null) {
+      throw new APIError({ message: `${operation}: empty response received`, code: "EMPTY_RESPONSE", details: response });
+    }
+    if (!this.isSafeApiResponse(response)) {
+      throw new APIError({ message: `${operation}: invalid SafeCDX response structure`, code: "INVALID_RESPONSE", details: response });
+    }
+    if (!response.success) {
+      throw new HCServiceError(
+        operation,
+        (_a = response.message) != null ? _a : "Backend returned success: false",
+        response
+      );
+    }
+    return response;
   }
-  getJsonHeaders() {
-    return {
-      ...this.getAuthHeaders(),
-      "Content-Type": "application/json"
-    };
+  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";
   }
-  getApiKeyHeader() {
-    if (!this.apiKeyHeaderName || !this.apiKeyValue) {
-      return {};
-    }
-    return {
-      [this.apiKeyHeaderName]: this.apiKeyValue
-    };
+  getAuthHeaders() {
+    return { ...this.getHeaders(), ...this.auth.getAuthHeader() };
   }
   url(route, query) {
     return buildUrl(this.baseUrl, route, query);
@@ -275,13 +322,18 @@ var HCSafeCDXClient = class {
 };
 
 // src/errors.ts
-var ConfigError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ConfigError";
-  }
-};
+import {
+  APIError as APIError2,
+  ConfigError as ConfigError2,
+  HCServiceError as HCServiceError2,
+  NetworkError,
+  ValidationError as ValidationError2
+} from "@healthcloudai/hc-http";
 export {
-  ConfigError,
-  HCSafeCDXClient
+  APIError2 as APIError,
+  ConfigError2 as ConfigError,
+  HCSafeCDXClient,
+  HCServiceError2 as HCServiceError,
+  NetworkError,
+  ValidationError2 as ValidationError
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@healthcloudai/hc-safe-cdx",
-  "version": "0.2.2",
+  "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.0.6",
-    "@healthcloudai/hc-login-connector": "^0.1.0"
+    "@healthcloudai/hc-http": "^0.2.0",
+    "@healthcloudai/hc-login-connector": "^0.3.0"
   },
   "peerDependencies": {
     "react-native": ">=0.70.0"