@fhirfly-io/terminology 0.1.0

package/dist/index.cjs

@@ -0,0 +1,718 @@
+'use strict';
+
+// src/errors.ts
+var FhirflyError = class _FhirflyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FhirflyError";
+    Object.setPrototypeOf(this, _FhirflyError.prototype);
+  }
+};
+var ApiError = class _ApiError extends FhirflyError {
+  statusCode;
+  code;
+  details;
+  constructor(message, statusCode, code, details) {
+    super(message);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, _ApiError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends ApiError {
+  constructor(message = "Authentication failed. Check your API key.") {
+    super(message, 401, "AUTHENTICATION_ERROR");
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends ApiError {
+  code_type;
+  code_value;
+  constructor(codeType, codeValue) {
+    super(`${codeType} not found: ${codeValue}`, 404, "NOT_FOUND");
+    this.name = "NotFoundError";
+    this.code_type = codeType;
+    this.code_value = codeValue;
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends ApiError {
+  field;
+  constructor(message, field) {
+    super(message, 400, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.field = field;
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends ApiError {
+  retryAfter;
+  limit;
+  remaining;
+  reset;
+  constructor(message = "Rate limit exceeded", retryAfter, limit, remaining, reset) {
+    super(message, 429, "RATE_LIMIT_EXCEEDED");
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+    this.limit = limit;
+    this.remaining = remaining;
+    this.reset = reset;
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var QuotaExceededError = class _QuotaExceededError extends ApiError {
+  quotaLimit;
+  quotaUsed;
+  quotaResetDate;
+  constructor(message = "Monthly quota exceeded", quotaLimit, quotaUsed, quotaResetDate) {
+    super(message, 429, "QUOTA_EXCEEDED");
+    this.name = "QuotaExceededError";
+    this.quotaLimit = quotaLimit;
+    this.quotaUsed = quotaUsed;
+    this.quotaResetDate = quotaResetDate;
+    Object.setPrototypeOf(this, _QuotaExceededError.prototype);
+  }
+};
+var ServerError = class _ServerError extends ApiError {
+  constructor(message = "Server error", statusCode = 500) {
+    super(message, statusCode, "SERVER_ERROR");
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends FhirflyError {
+  cause;
+  constructor(message = "Network error", cause) {
+    super(message);
+    this.name = "NetworkError";
+    this.cause = cause;
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends FhirflyError {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "TimeoutError";
+    this.timeoutMs = timeoutMs;
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+
+// src/http.ts
+var HttpClient = class {
+  config;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      timeout: config.timeout ?? 3e4,
+      maxRetries: config.maxRetries ?? 3,
+      retryDelay: config.retryDelay ?? 1e3,
+      userAgent: config.userAgent ?? `@fhirfly/sdk/0.1.0 Node.js/${process.version}`
+    };
+  }
+  /**
+   * Build query string from options.
+   */
+  buildQueryString(options) {
+    if (!options) return "";
+    const params = new URLSearchParams();
+    if (options.shape) {
+      params.set("shape", options.shape);
+    }
+    if (options.include?.length) {
+      params.set("include", options.include.join(","));
+    }
+    const queryString = params.toString();
+    return queryString ? `?${queryString}` : "";
+  }
+  /**
+   * Parse error response from API.
+   */
+  async parseErrorResponse(response, endpoint) {
+    const status = response.status;
+    let body = {};
+    try {
+      body = await response.json();
+    } catch {
+    }
+    const message = body.message || body.error || response.statusText;
+    switch (status) {
+      case 401:
+        throw new AuthenticationError(message);
+      case 404: {
+        const match = endpoint.match(/\/v1\/(\w+)\/(.+)/);
+        if (match) {
+          throw new NotFoundError(match[1].toUpperCase(), match[2]);
+        }
+        throw new NotFoundError("Resource", endpoint);
+      }
+      case 400:
+        throw new ValidationError(message);
+      case 429: {
+        const retryAfter = response.headers.get("retry-after");
+        const limit = response.headers.get("x-ratelimit-limit");
+        const remaining = response.headers.get("x-ratelimit-remaining");
+        const reset = response.headers.get("x-ratelimit-reset");
+        if (body.code === "QUOTA_EXCEEDED") {
+          throw new QuotaExceededError(message);
+        }
+        throw new RateLimitError(
+          message,
+          retryAfter ? parseInt(retryAfter, 10) : void 0,
+          limit ? parseInt(limit, 10) : void 0,
+          remaining ? parseInt(remaining, 10) : void 0,
+          reset ? new Date(parseInt(reset, 10) * 1e3) : void 0
+        );
+      }
+      default:
+        if (status >= 500) {
+          throw new ServerError(message, status);
+        }
+        throw new ApiError(message, status, body.code, body.details);
+    }
+  }
+  /**
+   * Sleep for a given number of milliseconds.
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Make an HTTP request with retries.
+   */
+  async request(method, endpoint, body) {
+    const url = `${this.config.baseUrl}${endpoint}`;
+    let lastError;
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(
+          () => controller.abort(),
+          this.config.timeout
+        );
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Authorization": `Bearer ${this.config.apiKey}`,
+            "Content-Type": "application/json",
+            "User-Agent": this.config.userAgent,
+            "Accept": "application/json"
+          },
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          if (response.status < 500 && response.status !== 429) {
+            await this.parseErrorResponse(response, endpoint);
+          }
+          if (response.status === 429) {
+            const retryAfter = response.headers.get("retry-after");
+            if (retryAfter && attempt < this.config.maxRetries) {
+              await this.sleep(parseInt(retryAfter, 10) * 1e3);
+              continue;
+            }
+            await this.parseErrorResponse(response, endpoint);
+          }
+          if (attempt < this.config.maxRetries) {
+            await this.sleep(this.config.retryDelay * Math.pow(2, attempt));
+            continue;
+          }
+          await this.parseErrorResponse(response, endpoint);
+        }
+        const data = await response.json();
+        return { data, status: response.status, headers: response.headers };
+      } catch (error) {
+        if (error instanceof ApiError) {
+          throw error;
+        }
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            throw new TimeoutError(this.config.timeout);
+          }
+          lastError = error;
+          if (attempt < this.config.maxRetries) {
+            await this.sleep(this.config.retryDelay * Math.pow(2, attempt));
+            continue;
+          }
+        }
+        throw new NetworkError(
+          lastError?.message || "Unknown network error",
+          lastError
+        );
+      }
+    }
+    throw new NetworkError(
+      lastError?.message || "Request failed after retries",
+      lastError
+    );
+  }
+  /**
+   * Make a GET request.
+   */
+  async get(endpoint, options) {
+    const queryString = this.buildQueryString(options);
+    const response = await this.request("GET", `${endpoint}${queryString}`);
+    return response.data;
+  }
+  /**
+   * Make a POST request.
+   */
+  async post(endpoint, body, options) {
+    const queryString = this.buildQueryString(options);
+    const response = await this.request("POST", `${endpoint}${queryString}`, body);
+    return response.data;
+  }
+};
+
+// src/endpoints/ndc.ts
+var NdcEndpoint = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Look up a single NDC code.
+   *
+   * @param code - NDC code (10-digit, 11-digit, or hyphenated format)
+   * @param options - Response shape and include options
+   * @returns NDC data
+   *
+   * @example
+   * ```ts
+   * const ndc = await client.ndc.lookup("0069-0151-01");
+   * console.log(ndc.data.product_name); // "Lipitor"
+   * ```
+   */
+  async lookup(code, options) {
+    return this.http.get(`/v1/ndc/${encodeURIComponent(code)}`, options);
+  }
+  /**
+   * Look up multiple NDC codes in a single request.
+   *
+   * @param codes - Array of NDC codes (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each code
+   *
+   * @example
+   * ```ts
+   * const results = await client.ndc.lookupMany([
+   *   "0069-0151-01",
+   *   "0069-0151-02",
+   *   "invalid-code"
+   * ]);
+   *
+   * for (const item of results.results) {
+   *   if (item.found) {
+   *     console.log(item.data.product_name);
+   *   } else {
+   *     console.log(`Not found: ${item.code}`);
+   *   }
+   * }
+   * ```
+   */
+  async lookupMany(codes, options) {
+    return this.http.post(
+      "/v1/ndc/_batch",
+      { codes },
+      options
+    );
+  }
+};
+
+// src/endpoints/npi.ts
+var NpiEndpoint = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Look up a single NPI.
+   *
+   * @param npi - 10-digit NPI number
+   * @param options - Response shape and include options
+   * @returns NPI data
+   *
+   * @example
+   * ```ts
+   * const npi = await client.npi.lookup("1234567890");
+   * console.log(npi.data.name);
+   * ```
+   */
+  async lookup(npi, options) {
+    return this.http.get(`/v1/npi/${encodeURIComponent(npi)}`, options);
+  }
+  /**
+   * Look up multiple NPIs in a single request.
+   *
+   * @param npis - Array of 10-digit NPI numbers (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each NPI
+   *
+   * @example
+   * ```ts
+   * const results = await client.npi.lookupMany([
+   *   "1234567890",
+   *   "0987654321"
+   * ]);
+   * ```
+   */
+  async lookupMany(npis, options) {
+    return this.http.post(
+      "/v1/npi/_batch",
+      { codes: npis },
+      options
+    );
+  }
+};
+
+// src/endpoints/rxnorm.ts
+var RxNormEndpoint = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Look up a single RxCUI.
+   *
+   * @param rxcui - RxNorm Concept Unique Identifier
+   * @param options - Response shape and include options
+   * @returns RxNorm data
+   *
+   * @example
+   * ```ts
+   * const rx = await client.rxnorm.lookup("213169");
+   * console.log(rx.data.name); // "atorvastatin 10 MG Oral Tablet"
+   * ```
+   */
+  async lookup(rxcui, options) {
+    return this.http.get(`/v1/rxnorm/${encodeURIComponent(rxcui)}`, options);
+  }
+  /**
+   * Look up multiple RxCUIs in a single request.
+   *
+   * @param rxcuis - Array of RxCUIs (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each RxCUI
+   */
+  async lookupMany(rxcuis, options) {
+    return this.http.post(
+      "/v1/rxnorm/_batch",
+      { codes: rxcuis },
+      options
+    );
+  }
+};
+
+// src/endpoints/loinc.ts
+var LoincEndpoint = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Look up a single LOINC code.
+   *
+   * @param loincNum - LOINC number (e.g., "2345-7")
+   * @param options - Response shape and include options
+   * @returns LOINC data
+   *
+   * @example
+   * ```ts
+   * const loinc = await client.loinc.lookup("2345-7");
+   * console.log(loinc.data.long_common_name); // "Glucose [Mass/volume] in Serum or Plasma"
+   * ```
+   */
+  async lookup(loincNum, options) {
+    return this.http.get(`/v1/loinc/${encodeURIComponent(loincNum)}`, options);
+  }
+  /**
+   * Look up multiple LOINC codes in a single request.
+   *
+   * @param loincNums - Array of LOINC numbers (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each LOINC
+   */
+  async lookupMany(loincNums, options) {
+    return this.http.post(
+      "/v1/loinc/_batch",
+      { codes: loincNums },
+      options
+    );
+  }
+};
+
+// src/endpoints/icd10.ts
+var Icd10Endpoint = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Look up a single ICD-10-CM code (diagnoses).
+   *
+   * @param code - ICD-10-CM code (e.g., "E11.9")
+   * @param options - Response shape and include options
+   * @returns ICD-10 data
+   *
+   * @example
+   * ```ts
+   * const icd = await client.icd10.lookupCm("E11.9");
+   * console.log(icd.data.description); // "Type 2 diabetes mellitus without complications"
+   * ```
+   */
+  async lookupCm(code, options) {
+    return this.http.get(`/v1/icd10/cm/${encodeURIComponent(code)}`, options);
+  }
+  /**
+   * Look up a single ICD-10-PCS code (procedures).
+   *
+   * @param code - ICD-10-PCS code (e.g., "0BJ08ZZ")
+   * @param options - Response shape and include options
+   * @returns ICD-10 data
+   *
+   * @example
+   * ```ts
+   * const icd = await client.icd10.lookupPcs("0BJ08ZZ");
+   * console.log(icd.data.description);
+   * ```
+   */
+  async lookupPcs(code, options) {
+    return this.http.get(`/v1/icd10/pcs/${encodeURIComponent(code)}`, options);
+  }
+  /**
+   * Look up multiple ICD-10-CM codes in a single request.
+   *
+   * @param codes - Array of ICD-10-CM codes (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each code
+   */
+  async lookupCmMany(codes, options) {
+    return this.http.post(
+      "/v1/icd10/cm/_batch",
+      { codes },
+      options
+    );
+  }
+  /**
+   * Look up multiple ICD-10-PCS codes in a single request.
+   *
+   * @param codes - Array of ICD-10-PCS codes (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each code
+   */
+  async lookupPcsMany(codes, options) {
+    return this.http.post(
+      "/v1/icd10/pcs/_batch",
+      { codes },
+      options
+    );
+  }
+};
+
+// src/endpoints/cvx.ts
+var CvxEndpoint = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Look up a single CVX code.
+   *
+   * @param cvxCode - CVX vaccine code
+   * @param options - Response shape and include options
+   * @returns CVX data
+   *
+   * @example
+   * ```ts
+   * const cvx = await client.cvx.lookup("208");
+   * console.log(cvx.data.short_description); // "COVID-19, mRNA, LNP-S, PF, 30 mcg/0.3 mL dose"
+   * ```
+   */
+  async lookup(cvxCode, options) {
+    return this.http.get(`/v1/cvx/${encodeURIComponent(cvxCode)}`, options);
+  }
+  /**
+   * Look up multiple CVX codes in a single request.
+   *
+   * @param cvxCodes - Array of CVX codes (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each code
+   */
+  async lookupMany(cvxCodes, options) {
+    return this.http.post(
+      "/v1/cvx/_batch",
+      { codes: cvxCodes },
+      options
+    );
+  }
+};
+
+// src/endpoints/mvx.ts
+var MvxEndpoint = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Look up a single MVX code.
+   *
+   * @param mvxCode - MVX manufacturer code
+   * @param options - Response shape and include options
+   * @returns MVX data
+   *
+   * @example
+   * ```ts
+   * const mvx = await client.mvx.lookup("PFR");
+   * console.log(mvx.data.manufacturer_name); // "Pfizer, Inc"
+   * ```
+   */
+  async lookup(mvxCode, options) {
+    return this.http.get(`/v1/mvx/${encodeURIComponent(mvxCode)}`, options);
+  }
+  /**
+   * Look up multiple MVX codes in a single request.
+   *
+   * @param mvxCodes - Array of MVX codes (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each code
+   */
+  async lookupMany(mvxCodes, options) {
+    return this.http.post(
+      "/v1/mvx/_batch",
+      { codes: mvxCodes },
+      options
+    );
+  }
+};
+
+// src/endpoints/fda-labels.ts
+var FdaLabelsEndpoint = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Look up FDA label by Set ID.
+   *
+   * @param setId - FDA SPL Set ID
+   * @param options - Response shape and include options
+   * @returns FDA Label data
+   *
+   * @example
+   * ```ts
+   * const label = await client.fdaLabels.lookup("abc123-def456");
+   * console.log(label.data.indications_and_usage);
+   * ```
+   */
+  async lookup(setId, options) {
+    return this.http.get(`/v1/fda-labels/${encodeURIComponent(setId)}`, options);
+  }
+  /**
+   * Look up FDA label by NDC code.
+   *
+   * @param ndc - NDC code
+   * @param options - Response shape and include options
+   * @returns FDA Label data
+   *
+   * @example
+   * ```ts
+   * const label = await client.fdaLabels.lookupByNdc("0069-0151-01");
+   * console.log(label.data.product_name);
+   * ```
+   */
+  async lookupByNdc(ndc, options) {
+    return this.http.get(`/v1/fda-labels/ndc/${encodeURIComponent(ndc)}`, options);
+  }
+  /**
+   * Look up multiple FDA labels by Set IDs in a single request.
+   *
+   * @param setIds - Array of Set IDs (max 500)
+   * @param options - Response shape, include, and batch options
+   * @returns Batch response with results for each Set ID
+   */
+  async lookupMany(setIds, options) {
+    return this.http.post(
+      "/v1/fda-labels/_batch",
+      { codes: setIds },
+      options
+    );
+  }
+};
+
+// src/client.ts
+var Fhirfly = class {
+  http;
+  /**
+   * NDC (National Drug Code) lookups.
+   */
+  ndc;
+  /**
+   * NPI (National Provider Identifier) lookups.
+   */
+  npi;
+  /**
+   * RxNorm drug terminology lookups.
+   */
+  rxnorm;
+  /**
+   * LOINC laboratory and clinical observation code lookups.
+   */
+  loinc;
+  /**
+   * ICD-10 diagnosis and procedure code lookups.
+   */
+  icd10;
+  /**
+   * CVX vaccine code lookups.
+   */
+  cvx;
+  /**
+   * MVX vaccine manufacturer code lookups.
+   */
+  mvx;
+  /**
+   * FDA drug label lookups.
+   */
+  fdaLabels;
+  /**
+   * Create a new FHIRfly client.
+   *
+   * @param config - Client configuration
+   * @throws {Error} If apiKey is not provided
+   */
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error(
+        "FHIRfly API key is required. Get one at https://fhirfly.io/dashboard"
+      );
+    }
+    const httpConfig = {
+      baseUrl: config.baseUrl ?? "https://api.fhirfly.io",
+      apiKey: config.apiKey,
+      timeout: config.timeout,
+      maxRetries: config.maxRetries,
+      retryDelay: config.retryDelay
+    };
+    this.http = new HttpClient(httpConfig);
+    this.ndc = new NdcEndpoint(this.http);
+    this.npi = new NpiEndpoint(this.http);
+    this.rxnorm = new RxNormEndpoint(this.http);
+    this.loinc = new LoincEndpoint(this.http);
+    this.icd10 = new Icd10Endpoint(this.http);
+    this.cvx = new CvxEndpoint(this.http);
+    this.mvx = new MvxEndpoint(this.http);
+    this.fdaLabels = new FdaLabelsEndpoint(this.http);
+  }
+};
+
+exports.ApiError = ApiError;
+exports.AuthenticationError = AuthenticationError;
+exports.Fhirfly = Fhirfly;
+exports.FhirflyError = FhirflyError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.QuotaExceededError = QuotaExceededError;
+exports.RateLimitError = RateLimitError;
+exports.ServerError = ServerError;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map