gdc-sdk-node-ts 2.9.20 → 2.9.21

package/dist/terminology-service-client.d.ts

@@ -1,7 +1,7 @@
 /** Input resolved by an authenticated application BFF, never directly by a browser. */
 export type TerminologyValueSetInput = Readonly<{
-    sector: string;
-    resourceType: string;
+    /** Optional per-request override. Dedicated BFFs normally configure this once on the client. */
+    sector?: string;
     claim: string;
     fhirVersion?: 'R4';
     language?: string;
@@ -11,6 +11,7 @@ export type TerminologyValueSetInput = Readonly<{
     offset?: number;
     count?: number;
 }>;
+export type TerminologyValueSetCodeListInput = Omit<TerminologyValueSetInput, 'offset' | 'count'>;
 export type TerminologyValueSetOption = Readonly<{
     system: string;
     code: string;
@@ -66,11 +67,23 @@ export type TerminologyValueSetResult = Readonly<{
     document: TerminologyValueSetDocument;
     cacheStatus: 'remote' | 'fresh-cache' | 'stale-cache' | 'english-fallback-cache';
 }>;
+/** Frontend-ready code list. Coding system and code remain separate FHIR Coding values. */
+export type TerminologyValueSetCodeList = Readonly<{
+    codingSystem: string;
+    codeToDisplay: Readonly<Record<string, string>>;
+    requestedLanguage: string;
+    resolvedLanguage: string;
+    fallbackUsed: boolean;
+    valueSet: TerminologyValueSetDocument['meta']['valueSet'];
+    terminologyVersions?: Readonly<Record<string, string>>;
+}>;
 /** Server-only client for a product-neutral terminology service. */
 export declare class TerminologyServiceClient {
     #private;
     constructor(options: Readonly<{
         baseUrl: string;
+        /** Default sector for a dedicated human-health or animal-health BFF. */
+        sector?: string;
         serviceToken?: string;
         fetchImplementation?: typeof fetch;
         cache?: TerminologyValueSetCache;
@@ -80,4 +93,6 @@ export declare class TerminologyServiceClient {
     }>);
     /** Resolves the ValueSet bound by the service to one canonical flat claim. */
     expandValueSetForClaim(input: TerminologyValueSetInput): Promise<TerminologyValueSetResult>;
+    /** Resolves every page and returns the simple code-to-display object expected by forms. */
+    getValueSetCodeListForClaim(input: TerminologyValueSetCodeListInput): Promise<TerminologyValueSetCodeList>;
 }

package/dist/terminology-service-client.js

@@ -9,12 +9,10 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _MemoryTerminologyValueSetCache_entries, _TerminologyServiceClient_instances, _TerminologyServiceClient_baseUrl, _TerminologyServiceClient_serviceToken, _TerminologyServiceClient_fetch, _TerminologyServiceClient_cache, _TerminologyServiceClient_cacheTtlMs, _TerminologyServiceClient_staleIfError, _TerminologyServiceClient_now, _TerminologyServiceClient_request, _TerminologyServiceClient_validateInput, _TerminologyServiceClient_isDocument;
+var _MemoryTerminologyValueSetCache_entries, _TerminologyServiceClient_instances, _TerminologyServiceClient_baseUrl, _TerminologyServiceClient_serviceToken, _TerminologyServiceClient_sector, _TerminologyServiceClient_fetch, _TerminologyServiceClient_cache, _TerminologyServiceClient_cacheTtlMs, _TerminologyServiceClient_staleIfError, _TerminologyServiceClient_now, _TerminologyServiceClient_request, _TerminologyServiceClient_validateInput, _TerminologyServiceClient_isDocument;
 const DEFAULT_TTL_MS = 5 * 60 * 1000;
 function normalizedInput(input) {
     return {
-        sector: input.sector.trim().toLowerCase(),
-        resourceType: input.resourceType.trim(),
         claim: input.claim.trim(),
         fhirVersion: input.fhirVersion ?? 'R4',
         language: (input.language?.trim() || 'en').replace(/_/g, '-').toLowerCase(),
@@ -26,13 +24,27 @@ function normalizedInput(input) {
 }
 /** Stable key usable by in-memory, GCS, Firestore or PostgreSQL cache adapters. */
 export function terminologyValueSetCacheKey(input) {
-    const value = normalizedInput(input);
+    const normalizedTerminologyContext = normalizedInput(input);
     return JSON.stringify([
-        value.fhirVersion, value.sector, value.resourceType, value.claim,
-        value.language, value.jurisdiction ?? '', value.version ?? 'latest',
-        value.offset, value.count,
+        normalizedTerminologyContext.fhirVersion,
+        input.sector?.trim().toLowerCase() ?? '',
+        normalizedTerminologyContext.claim,
+        normalizedTerminologyContext.language,
+        normalizedTerminologyContext.jurisdiction ?? '',
+        normalizedTerminologyContext.version ?? 'latest',
+        normalizedTerminologyContext.offset,
+        normalizedTerminologyContext.count,
     ]);
 }
+function resourceTypeFromClaim(claim) {
+    const canonicalClaim = claim.trim();
+    const separatorIndex = canonicalClaim.indexOf('.');
+    const resourceType = canonicalClaim.slice(0, separatorIndex);
+    if (separatorIndex < 1 || !/^[A-Z][A-Za-z0-9]*$/.test(resourceType)) {
+        throw new Error('claim must start with its FHIR resource type');
+    }
+    return resourceType;
+}
 /** Process-local cache suitable for warm BFF instances and immutable startup snapshots. */
 export class MemoryTerminologyValueSetCache {
     constructor() {
@@ -55,6 +67,7 @@ export class TerminologyServiceClient {
         _TerminologyServiceClient_instances.add(this);
         _TerminologyServiceClient_baseUrl.set(this, void 0);
         _TerminologyServiceClient_serviceToken.set(this, void 0);
+        _TerminologyServiceClient_sector.set(this, void 0);
         _TerminologyServiceClient_fetch.set(this, void 0);
         _TerminologyServiceClient_cache.set(this, void 0);
         _TerminologyServiceClient_cacheTtlMs.set(this, void 0);
@@ -62,6 +75,7 @@ export class TerminologyServiceClient {
         _TerminologyServiceClient_now.set(this, void 0);
         __classPrivateFieldSet(this, _TerminologyServiceClient_baseUrl, options.baseUrl.replace(/\/$/, ''), "f");
         __classPrivateFieldSet(this, _TerminologyServiceClient_serviceToken, options.serviceToken?.trim() || undefined, "f");
+        __classPrivateFieldSet(this, _TerminologyServiceClient_sector, options.sector?.trim() || undefined, "f");
         __classPrivateFieldSet(this, _TerminologyServiceClient_fetch, options.fetchImplementation ?? fetch, "f");
         __classPrivateFieldSet(this, _TerminologyServiceClient_cache, options.cache ?? new MemoryTerminologyValueSetCache(), "f");
         __classPrivateFieldSet(this, _TerminologyServiceClient_cacheTtlMs, options.cacheTtlMs ?? DEFAULT_TTL_MS, "f");
@@ -71,13 +85,17 @@ export class TerminologyServiceClient {
     /** Resolves the ValueSet bound by the service to one canonical flat claim. */
     async expandValueSetForClaim(input) {
         __classPrivateFieldGet(this, _TerminologyServiceClient_instances, "m", _TerminologyServiceClient_validateInput).call(this, input);
-        const key = terminologyValueSetCacheKey(input);
+        const resolvedTerminologyContext = {
+            ...input,
+            sector: input.sector?.trim() || __classPrivateFieldGet(this, _TerminologyServiceClient_sector, "f"),
+        };
+        const key = terminologyValueSetCacheKey(resolvedTerminologyContext);
         const cached = await __classPrivateFieldGet(this, _TerminologyServiceClient_cache, "f").get(key);
         if (cached && __classPrivateFieldGet(this, _TerminologyServiceClient_now, "f").call(this) - cached.storedAt <= __classPrivateFieldGet(this, _TerminologyServiceClient_cacheTtlMs, "f")) {
             return { document: cached.document, cacheStatus: 'fresh-cache' };
         }
         try {
-            const document = await __classPrivateFieldGet(this, _TerminologyServiceClient_instances, "m", _TerminologyServiceClient_request).call(this, input);
+            const document = await __classPrivateFieldGet(this, _TerminologyServiceClient_instances, "m", _TerminologyServiceClient_request).call(this, resolvedTerminologyContext);
             await __classPrivateFieldGet(this, _TerminologyServiceClient_cache, "f").set(key, { document, storedAt: __classPrivateFieldGet(this, _TerminologyServiceClient_now, "f").call(this) });
             return { document, cacheStatus: 'remote' };
         }
@@ -87,7 +105,10 @@ export class TerminologyServiceClient {
             }
             const requestedLanguage = input.language?.trim().toLowerCase();
             if (__classPrivateFieldGet(this, _TerminologyServiceClient_staleIfError, "f") && requestedLanguage && requestedLanguage !== 'en') {
-                const english = await __classPrivateFieldGet(this, _TerminologyServiceClient_cache, "f").get(terminologyValueSetCacheKey({ ...input, language: 'en' }));
+                const english = await __classPrivateFieldGet(this, _TerminologyServiceClient_cache, "f").get(terminologyValueSetCacheKey({
+                    ...resolvedTerminologyContext,
+                    language: 'en',
+                }));
                 if (english) {
                     return { document: english.document, cacheStatus: 'english-fallback-cache' };
                 }
@@ -95,11 +116,61 @@ export class TerminologyServiceClient {
             throw new Error('Terminology service request failed');
         }
     }
+    /** Resolves every page and returns the simple code-to-display object expected by forms. */
+    async getValueSetCodeListForClaim(input) {
+        const pageSize = 100;
+        let nextOffset = 0;
+        let totalOptionCount = 0;
+        let codingSystem = '';
+        let resolvedLanguage = '';
+        let fallbackUsed = false;
+        let resolvedValueSet;
+        let terminologyVersions;
+        const codeToDisplay = {};
+        do {
+            const valueSetPage = await this.expandValueSetForClaim({
+                ...input,
+                offset: nextOffset,
+                count: pageSize,
+            });
+            const { document } = valueSetPage;
+            totalOptionCount = document.meta.total;
+            resolvedLanguage || (resolvedLanguage = document.meta.language);
+            resolvedValueSet ?? (resolvedValueSet = document.meta.valueSet);
+            terminologyVersions ?? (terminologyVersions = document.meta.terminologyVersions);
+            if (resolvedValueSet.system !== document.meta.valueSet.system) {
+                throw new Error('Terminology service returned inconsistent ValueSet pages');
+            }
+            for (const terminologyOptionResource of document.data) {
+                const terminologyOption = terminologyOptionResource.attributes;
+                if (codingSystem && codingSystem !== terminologyOption.system) {
+                    throw new Error('Terminology ValueSet contains more than one coding system');
+                }
+                codingSystem || (codingSystem = terminologyOption.system);
+                codeToDisplay[terminologyOption.code] = terminologyOption.localizedDisplay;
+                fallbackUsed || (fallbackUsed = terminologyOption.fallbackUsed);
+            }
+            if (document.data.length === 0 && nextOffset < totalOptionCount) {
+                throw new Error('Terminology service returned an incomplete ValueSet page');
+            }
+            nextOffset += document.data.length;
+        } while (nextOffset < totalOptionCount);
+        if (!resolvedValueSet)
+            throw new Error('Terminology service returned no ValueSet metadata');
+        return {
+            codingSystem: codingSystem || resolvedValueSet.system,
+            codeToDisplay,
+            requestedLanguage: (input.language?.trim() || 'en').replace(/_/g, '-').toLowerCase(),
+            resolvedLanguage: resolvedLanguage || 'en',
+            fallbackUsed,
+            valueSet: resolvedValueSet,
+            ...(terminologyVersions ? { terminologyVersions } : {}),
+        };
+    }
 }
-_TerminologyServiceClient_baseUrl = new WeakMap(), _TerminologyServiceClient_serviceToken = new WeakMap(), _TerminologyServiceClient_fetch = new WeakMap(), _TerminologyServiceClient_cache = new WeakMap(), _TerminologyServiceClient_cacheTtlMs = new WeakMap(), _TerminologyServiceClient_staleIfError = new WeakMap(), _TerminologyServiceClient_now = new WeakMap(), _TerminologyServiceClient_instances = new WeakSet(), _TerminologyServiceClient_request = async function _TerminologyServiceClient_request(input) {
+_TerminologyServiceClient_baseUrl = new WeakMap(), _TerminologyServiceClient_serviceToken = new WeakMap(), _TerminologyServiceClient_sector = new WeakMap(), _TerminologyServiceClient_fetch = new WeakMap(), _TerminologyServiceClient_cache = new WeakMap(), _TerminologyServiceClient_cacheTtlMs = new WeakMap(), _TerminologyServiceClient_staleIfError = new WeakMap(), _TerminologyServiceClient_now = new WeakMap(), _TerminologyServiceClient_instances = new WeakSet(), _TerminologyServiceClient_request = async function _TerminologyServiceClient_request(input) {
     const url = new URL(`${__classPrivateFieldGet(this, _TerminologyServiceClient_baseUrl, "f")}/v1/terminology/value-set-options`);
-    url.searchParams.set('sector', input.sector.trim());
-    url.searchParams.set('resourceType', input.resourceType.trim());
+    url.searchParams.set('sector', input.sector?.trim() || __classPrivateFieldGet(this, _TerminologyServiceClient_sector, "f") || '');
     url.searchParams.set('claim', input.claim.trim());
     url.searchParams.set('offset', String(input.offset ?? 0));
     url.searchParams.set('count', String(input.count ?? 50));
@@ -124,12 +195,11 @@ _TerminologyServiceClient_baseUrl = new WeakMap(), _TerminologyServiceClient_ser
         throw new Error('Terminology service returned an invalid document');
     return document;
 }, _TerminologyServiceClient_validateInput = function _TerminologyServiceClient_validateInput(input) {
-    if (!input.sector.trim())
+    if (!(input.sector?.trim() || __classPrivateFieldGet(this, _TerminologyServiceClient_sector, "f")))
         throw new Error('sector is required');
-    if (!input.resourceType.trim())
-        throw new Error('resourceType is required');
     if (!input.claim.trim())
         throw new Error('claim is required');
+    resourceTypeFromClaim(input.claim);
     if (input.offset !== undefined && (!Number.isInteger(input.offset) || input.offset < 0)) {
         throw new Error('offset must be a non-negative integer');
     }
@@ -142,7 +212,7 @@ _TerminologyServiceClient_baseUrl = new WeakMap(), _TerminologyServiceClient_ser
     const document = value;
     if (document.jsonapi?.version !== '1.1' || !Array.isArray(document.data) || !document.meta)
         return false;
-    if (document.meta.resourceType !== input.resourceType.trim() || document.meta.claim !== input.claim.trim())
+    if (document.meta.resourceType !== resourceTypeFromClaim(input.claim) || document.meta.claim !== input.claim.trim())
         return false;
     return document.data.every((resource) => (resource?.type === 'terminology-option'
         && typeof resource.id === 'string'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "2.9.20",
+  "version": "2.9.21",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -38,7 +38,7 @@
     "test:e2e:live-gw:clean": "bash ./scripts/run-live-gw-clean.sh"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "2.9.19",
+    "gdc-common-utils-ts": "2.9.20",
     "gdc-sdk-core-ts": "2.9.10"
   },
   "devDependencies": {