gdc-sdk-node-ts 0.6.3 → 0.6.6

package/README.md

@@ -77,6 +77,88 @@ Open these tests when you want to see exact method calls and exact inputs:
   Portal-style `default-first` discovery with simple `getHosts(...)`,
   `getIndexProviders(...)`, and `getDigitalTwinProviders(...)` calls.
 
+## Live GW CORE Flow
+
+Use [tests/live-gw-node-runtime.e2e.test.mjs](tests/live-gw-node-runtime.e2e.test.mjs)
+as the canonical runtime flow.
+
+Teaching rule:
+
+- defaults come from `gdc-common-utils-ts/examples`
+- override with env vars only when your tenant, bearer, or route is different
+- local GW default is `http://127.0.0.1:3000`
+- Docker-exposed GW can be overridden with `BASE_URL=http://127.0.0.1:8000`
+
+Current live flow covered by the test suite:
+
+1. bootstrap tenant / legal organization
+2. bootstrap doctor or controller employee
+3. bootstrap individual and grant consent for the doctor
+4. ingest two IPS `Communication` bundles, each with one `MedicationStatement`
+5. read the IPS/clinical index and verify both medications are present
+6. persist audit/debug traces in `test-results/*.jsonl`
+
+Shared example source of truth:
+
+- tenant/route/controller/professional defaults:
+  [gdc-common-utils-ts/src/examples/shared.ts](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/src/examples/shared.ts)
+- live employee defaults:
+  [gdc-common-utils-ts/src/examples/organization-controller.ts](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/src/examples/organization-controller.ts)
+- live consent defaults:
+  [gdc-common-utils-ts/src/examples/individual-controller.ts](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/src/examples/individual-controller.ts)
+
+The two medication defaults used by the live test are intentionally reusable:
+
+- `Ibuprofen 400 mg`
+- `Paracetamol 600 mg`
+- both every `8` hours
+- both `PRN` / `dosage-asneeded = true`
+- note text keeps the `4` hour gap in English
+
+Run the full live runtime baseline:
+
+```bash
+npm run test:e2e:live-gw
+```
+
+Run the IPS ingestion/search branch as well:
+
+```bash
+RUN_LIVE_GW_E2E_IPS_INGESTION=1 \
+npm run test:e2e:live-gw
+```
+
+Common overrides:
+
+```bash
+BASE_URL=http://127.0.0.1:3000 \
+AUTH_BEARER=... \
+TENANT_ID=VATES-B00112233 \
+TENANT_ROUTE_ID=acme-live \
+JURISDICTION=ES \
+SECTOR=health-care \
+SUBJECT_DID=did:web:api.acme.org:individual:123 \
+RUN_LIVE_GW_E2E_IPS_INGESTION=1 \
+LIVE_GW_NODE_E2E_DEBUG=1 \
+npm run test:e2e:live-gw
+```
+
+Docker-exposed GW example:
+
+```bash
+BASE_URL=http://127.0.0.1:8000 \
+RUN_LIVE_GW_E2E_IPS_INGESTION=1 \
+npm run test:e2e:live-gw
+```
+
+Documentation consistency rule for this repo family:
+
+- scripts, README examples, Swagger examples, and internal tests must reuse the
+  same example data and flow order
+- if a new request/response example is added, add it first to
+  `gdc-common-utils-ts/examples` and consume it from there instead of
+  re-hardcoding values locally
+
 ## Dataspace Discovery Quick Map
 
 Use the Node discovery layer when your backend or BFF needs to:

package/dist/discovery/DefaultFirstDataspaceDiscovery.d.ts

@@ -35,6 +35,8 @@ export declare class DefaultFirstDataspaceDiscovery {
     getDigitalTwinProviders(input: SimpleDataspaceDiscoveryRequest): Promise<PublishedProviderMatch[]>;
     private getProviders;
     private createResolver;
+    private buildBootstrapPlan;
+    private resolveDefaultPublishedProviders;
 }
 /**
  * Convenience factory for the default-first portal/backend discovery facade.

package/dist/discovery/DefaultFirstDataspaceDiscovery.js

@@ -1,9 +1,57 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { DataspaceDiscoverySourceMode, ServiceCapabilityToken, createDataspaceDiscoveryDefaultsRegistry, DataspaceProtocolVersions, } from 'gdc-common-utils-ts';
+import { DataspaceCoverageScope, DataspaceDiscoverySourceMode, ServiceCapabilityToken, createDataspaceDiscoveryDefaultsRegistry, DataspaceProtocolVersions, inferCoverageScopeFromCountryCode, isProviderServiceCapability, normalizeCountryCode, } from 'gdc-common-utils-ts';
 import { HttpDataspaceResolver } from './HttpDataspaceResolver.js';
 function normalizeString(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
+function equalsIgnoreCase(left, right) {
+    return left.trim().toLowerCase() === right.trim().toLowerCase();
+}
+function splitTokens(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeString(entry)).filter(Boolean);
+    }
+    const raw = normalizeString(value);
+    if (!raw)
+        return [];
+    return raw.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+function buildCoverageTokens(areaServed, filterJurisdiction) {
+    const tokens = new Set(splitTokens(areaServed).map((token) => token.toUpperCase()));
+    const normalizedJurisdiction = normalizeCountryCode(filterJurisdiction);
+    if (normalizedJurisdiction) {
+        const inferred = inferCoverageScopeFromCountryCode(normalizedJurisdiction);
+        if (inferred)
+            tokens.add(inferred.toUpperCase());
+    }
+    return tokens;
+}
+function matchesProviderCoverage(provider, jurisdiction, coverageScope) {
+    const normalizedJurisdiction = normalizeCountryCode(jurisdiction);
+    const normalizedCoverageScope = normalizeString(coverageScope).toUpperCase();
+    if (!normalizedJurisdiction && !normalizedCoverageScope)
+        return true;
+    const tokens = buildCoverageTokens(provider.areaServed, jurisdiction);
+    if (normalizedJurisdiction && tokens.has(normalizedJurisdiction))
+        return true;
+    if (normalizedCoverageScope && tokens.has(normalizedCoverageScope))
+        return true;
+    if (normalizedCoverageScope === DataspaceCoverageScope.EuropeanUnion) {
+        return Array.from(tokens).some((token) => inferCoverageScopeFromCountryCode(token) === DataspaceCoverageScope.EuropeanUnion);
+    }
+    return false;
+}
+function matchesDefaultPublishedProvider(provider, input, providerCapability) {
+    if (!equalsIgnoreCase(provider.category, input.sector))
+        return false;
+    if (!isProviderServiceCapability(provider.serviceType))
+        return false;
+    if (!equalsIgnoreCase(provider.serviceType, providerCapability))
+        return false;
+    if (!matchesProviderCoverage(provider, input.jurisdiction, input.coverageScope))
+        return false;
+    return true;
+}
 function isDefaultsRegistry(value) {
     return Boolean(value)
         && typeof value === 'object'
@@ -60,7 +108,15 @@ export class DefaultFirstDataspaceDiscovery {
         return this.getProviders(input, ServiceCapabilityToken.DigitalTwinProvider);
     }
     async getProviders(input, providerCapability) {
-        const resolver = this.createResolver(input, [providerCapability]);
+        const bootstrapPlan = this.buildBootstrapPlan(input, [providerCapability]);
+        const defaultPublishedProviders = this.resolveDefaultPublishedProviders(bootstrapPlan.hostingOperators, input, providerCapability);
+        if (defaultPublishedProviders.length > 0) {
+            return defaultPublishedProviders;
+        }
+        const resolver = new HttpDataspaceResolver({
+            hostingOperators: bootstrapPlan.hostingOperators,
+            fetcher: this.fetcher,
+        });
         return resolver.resolvePublishedProviders({
             sector: input.sector,
             jurisdiction: input.jurisdiction,
@@ -69,7 +125,14 @@ export class DefaultFirstDataspaceDiscovery {
         });
     }
     createResolver(input, requiredCapabilities) {
-        const bootstrapPlan = this.defaultsRegistry.buildBootstrapPlan({
+        const bootstrapPlan = this.buildBootstrapPlan(input, requiredCapabilities);
+        return new HttpDataspaceResolver({
+            hostingOperators: bootstrapPlan.hostingOperators,
+            fetcher: this.fetcher,
+        });
+    }
+    buildBootstrapPlan(input, requiredCapabilities) {
+        return this.defaultsRegistry.buildBootstrapPlan({
             jurisdiction: input.jurisdiction,
             version: this.version,
             networkType: this.networkType,
@@ -78,10 +141,18 @@ export class DefaultFirstDataspaceDiscovery {
             requiredCapabilities,
             sourceMode: DataspaceDiscoverySourceMode.DefaultFirst,
         });
-        return new HttpDataspaceResolver({
-            hostingOperators: bootstrapPlan.hostingOperators,
-            fetcher: this.fetcher,
-        });
+    }
+    resolveDefaultPublishedProviders(hosts, input, providerCapability) {
+        return hosts.flatMap((host) => (host.publishedProviders || [])
+            .filter((provider) => matchesDefaultPublishedProvider(provider, input, providerCapability))
+            .map((provider) => ({
+            providerDid: provider.providerDid,
+            record: provider,
+            hostingOperator: host.record,
+            hostingOperatorDid: host.operatorDid,
+            discoveryUrl: provider.discoveryUrl || host.discoveryUrl,
+            catalogUrl: provider.catalogUrl || host.catalogUrl,
+        })));
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "0.6.3",
+  "version": "0.6.6",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -17,8 +17,8 @@
     "test:e2e:live-gw": "npm run build && RUN_LIVE_GW_E2E=1 node --test tests/live-gw-node-runtime.e2e.test.mjs"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "^1.14.2",
-    "gdc-sdk-core-ts": "^0.6.3"
+    "gdc-common-utils-ts": "^1.14.10",
+    "gdc-sdk-core-ts": "^0.6.9"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",